diff --git a/apps/products/project.json b/apps/products/project.json index 05786fd0..20ee927b 100644 --- a/apps/products/project.json +++ b/apps/products/project.json @@ -11,7 +11,7 @@ "prefix": "nx-example", "targets": { "build": { - "executor": "@angular-devkit/build-angular:browser", + "executor": "@angular-devkit/build-angular:browser-rspack", "options": { "aot": true, "outputPath": "dist/apps/products", diff --git a/artifacts/build-angular/LICENSE b/artifacts/build-angular/LICENSE new file mode 100644 index 00000000..8876c32c --- /dev/null +++ b/artifacts/build-angular/LICENSE @@ -0,0 +1,21 @@ +The MIT License + +Copyright (c) 2017 Google, Inc. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/artifacts/build-angular/README.md b/artifacts/build-angular/README.md new file mode 100644 index 00000000..68cc3f37 --- /dev/null +++ b/artifacts/build-angular/README.md @@ -0,0 +1,20 @@ +# @angular-devkit/build-angular + +This package contains [Architect builders](/packages/angular_devkit/architect/README.md) used to build and test Angular applications and libraries. + +## Builders + +| Name | Description | +| ------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| app-shell | Build an Angular [App shell](https://angular.io/guide/app-shell). | +| browser | Build an Angular application targeting a browser environment. | +| dev-server | A development server that provides live reloading. | +| extract-i18n | Extract i18n messages from an Angular application. | +| karma | Execute unit tests using [Karma](https://github.com/karma-runner/karma) test runner. | +| ng-packagr | Build and package an Angular library in [Angular Package Format (APF)](https://angular.io/guide/angular-package-format) format using [ng-packagr](https://github.com/ng-packagr/ng-packagr). | +| server | Build an Angular application targeting a [Node.js](https://nodejs.org) environment. | +| protractor | **Deprecated** - Run end-to-end tests using [Protractor](https://www.protractortest.org/) framework. | + +## Disclaimer + +While the builders when executed via the Angular CLI and their associated options are considered stable, the programmatic APIs are not considered officially supported and are not subject to the breaking change guarantees of SemVer. diff --git a/artifacts/build-angular/builders.json b/artifacts/build-angular/builders.json new file mode 100644 index 00000000..caf2182e --- /dev/null +++ b/artifacts/build-angular/builders.json @@ -0,0 +1,60 @@ +{ + "$schema": "../architect/src/builders-schema.json", + "builders": { + "app-shell": { + "implementation": "./src/builders/app-shell", + "schema": "./src/builders/app-shell/schema.json", + "description": "Build a server application and a browser application, then render the index.html and use it for the browser output." + }, + "browser": { + "implementation": "./src/builders/browser", + "schema": "./src/builders/browser/schema.json", + "description": "Build a browser application." + }, + "browser-rspack": { + "implementation": "./src/builders/browser-rspack", + "schema": "./src/builders/browser-rspack/schema.json", + "description": "Build a browser application." + }, + "browser-esbuild": { + "implementation": "./src/builders/browser-esbuild", + "schema": "./src/builders/browser-esbuild/schema.json", + "description": "Build a browser application." + }, + "dev-server": { + "implementation": "./src/builders/dev-server", + "schema": "./src/builders/dev-server/schema.json", + "description": "Serve a browser application." + }, + "extract-i18n": { + "implementation": "./src/builders/extract-i18n", + "schema": "./src/builders/extract-i18n/schema.json", + "description": "Extract i18n strings from a browser application." + }, + "jest": { + "implementation": "./src/builders/jest", + "schema": "./src/builders/jest/schema.json", + "description": "Run unit tests using Jest." + }, + "karma": { + "implementation": "./src/builders/karma", + "schema": "./src/builders/karma/schema.json", + "description": "Run Karma unit tests." + }, + "protractor": { + "implementation": "./src/builders/protractor", + "schema": "./src/builders/protractor/schema.json", + "description": "Run protractor over a dev server." + }, + "server": { + "implementation": "./src/builders/server", + "schema": "./src/builders/server/schema.json", + "description": "Build a server Angular application." + }, + "ng-packagr": { + "implementation": "./src/builders/ng-packagr", + "schema": "./src/builders/ng-packagr/schema.json", + "description": "Build a library with ng-packagr." + } + } +} diff --git a/artifacts/build-angular/package.json b/artifacts/build-angular/package.json new file mode 100644 index 00000000..1ceb8ccc --- /dev/null +++ b/artifacts/build-angular/package.json @@ -0,0 +1,142 @@ +{ + "name": "@angular-devkit/build-angular", + "version": "16.0.0-next.0", + "description": "Angular Webpack Build Facade", + "main": "src/index.js", + "typings": "src/index.d.ts", + "builders": "builders.json", + "dependencies": { + "@ampproject/remapping": "2.2.1", + "@angular-devkit/architect": "0.1600.0-next.0", + "@angular-devkit/build-webpack": "0.1600.0-next.0", + "@angular-devkit/core": "16.0.0-next.0", + "@babel/core": "7.21.8", + "@babel/generator": "7.21.5", + "@babel/helper-annotate-as-pure": "7.18.6", + "@babel/helper-split-export-declaration": "7.18.6", + "@babel/plugin-proposal-async-generator-functions": "7.20.7", + "@babel/plugin-transform-async-to-generator": "7.20.7", + "@babel/plugin-transform-runtime": "7.21.4", + "@babel/preset-env": "7.21.5", + "@babel/runtime": "7.21.5", + "@babel/template": "7.20.7", + "@discoveryjs/json-ext": "0.5.7", + "@ngtools/webpack": "16.0.0-next.0", + "@vitejs/plugin-basic-ssl": "1.0.1", + "ansi-colors": "4.1.3", + "autoprefixer": "10.4.14", + "babel-loader": "9.1.2", + "babel-plugin-istanbul": "6.1.1", + "browserslist": "4.21.5", + "cacache": "17.1.0", + "chokidar": "3.5.3", + "copy-webpack-plugin": "11.0.0", + "critters": "0.0.16", + "css-loader": "6.7.3", + "esbuild-wasm": "0.17.18", + "glob": "8.1.0", + "https-proxy-agent": "5.0.1", + "inquirer": "8.2.4", + "jsonc-parser": "3.2.0", + "karma-source-map-support": "1.4.0", + "less": "4.1.3", + "less-loader": "11.1.0", + "license-webpack-plugin": "4.0.2", + "loader-utils": "3.2.1", + "magic-string": "0.30.0", + "mini-css-extract-plugin": "2.7.5", + "mrmime": "1.0.1", + "open": "8.4.2", + "ora": "5.4.1", + "parse5-html-rewriting-stream": "7.0.0", + "piscina": "3.2.0", + "postcss": "8.4.23", + "postcss-loader": "7.3.0", + "resolve-url-loader": "5.0.0", + "rxjs": "7.8.1", + "sass": "1.62.1", + "sass-loader": "13.2.2", + "semver": "7.5.0", + "source-map-loader": "4.0.1", + "source-map-support": "0.5.21", + "terser": "5.17.1", + "text-table": "0.2.0", + "tree-kill": "1.2.2", + "tslib": "2.5.0", + "vite": "4.3.4", + "webpack": "5.82.0", + "webpack-dev-middleware": "6.1.0", + "webpack-dev-server": "4.13.3", + "webpack-merge": "5.8.0", + "webpack-subresource-integrity": "5.1.0", + "@rspack/cli": "^0.1.10", + "@rspack/core": "^0.1.10" + }, + "optionalDependencies": { + "esbuild": "0.17.18" + }, + "peerDependencies": { + "@angular/compiler-cli": "^16.0.0 || ^16.1.0-next.0", + "@angular/localize": "^16.0.0 || ^16.1.0-next.0", + "@angular/platform-server": "^16.0.0 || ^16.1.0-next.0", + "@angular/service-worker": "^16.0.0 || ^16.1.0-next.0", + "jest": "^29.5.0", + "jest-environment-jsdom": "^29.5.0", + "karma": "^6.3.0", + "ng-packagr": "^16.0.0 || ^16.1.0-next.0", + "protractor": "^7.0.0", + "tailwindcss": "^2.0.0 || ^3.0.0", + "typescript": ">=4.9.3 <5.1" + }, + "peerDependenciesMeta": { + "@angular/localize": { + "optional": true + }, + "@angular/platform-server": { + "optional": true + }, + "@angular/service-worker": { + "optional": true + }, + "jest": { + "optional": true + }, + "jest-environment-jsdom": { + "optional": true + }, + "karma": { + "optional": true + }, + "ng-packagr": { + "optional": true + }, + "protractor": { + "optional": true + }, + "tailwindcss": { + "optional": true + } + }, + "keywords": [ + "Angular CLI", + "Angular DevKit", + "angular", + "devkit", + "sdk" + ], + "repository": { + "type": "git", + "url": "https://github.com/angular/angular-cli.git" + }, + "engines": { + "node": "^16.14.0 || >=18.10.0", + "npm": "^6.11.0 || ^7.5.6 || >=8.0.0", + "yarn": ">= 1.13.0" + }, + "author": "Angular Authors", + "license": "MIT", + "bugs": { + "url": "https://github.com/angular/angular-cli/issues" + }, + "homepage": "https://github.com/angular/angular-cli" +} diff --git a/artifacts/build-angular/plugins/karma.d.ts b/artifacts/build-angular/plugins/karma.d.ts new file mode 100644 index 00000000..823e9bf4 --- /dev/null +++ b/artifacts/build-angular/plugins/karma.d.ts @@ -0,0 +1,7 @@ +/** + * @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 + */ diff --git a/artifacts/build-angular/plugins/karma.js b/artifacts/build-angular/plugins/karma.js new file mode 100644 index 00000000..51e2e018 --- /dev/null +++ b/artifacts/build-angular/plugins/karma.js @@ -0,0 +1,10 @@ +"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 + */ +module.exports = require('../src/webpack/plugins/karma/karma'); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2FybWEuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9hbmd1bGFyX2RldmtpdC9idWlsZF9hbmd1bGFyL3BsdWdpbnMva2FybWEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7R0FNRztBQUVILE1BQU0sQ0FBQyxPQUFPLEdBQUcsT0FBTyxDQUFDLG9DQUFvQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxubW9kdWxlLmV4cG9ydHMgPSByZXF1aXJlKCcuLi9zcmMvd2VicGFjay9wbHVnaW5zL2thcm1hL2thcm1hJyk7XG4iXX0= \ No newline at end of file diff --git a/artifacts/build-angular/src/babel-bazel.d.ts b/artifacts/build-angular/src/babel-bazel.d.ts new file mode 100644 index 00000000..f52defff --- /dev/null +++ b/artifacts/build-angular/src/babel-bazel.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 + */ + +/* eslint-disable import/no-extraneous-dependencies */ +// Workaround for https://github.com/bazelbuild/rules_nodejs/issues/1033 +// Alternative approach instead of https://github.com/angular/angular/pull/33226 +declare module '@babel/core' { + export * from '@types/babel__core'; +} +declare module '@babel/generator' { + export { default } from '@types/babel__generator'; +} +declare module '@babel/traverse' { + export { default } from '@types/babel__traverse'; +} +declare module '@babel/template' { + export { default } from '@types/babel__template'; +} diff --git a/artifacts/build-angular/src/babel/babel-loader.d.ts b/artifacts/build-angular/src/babel/babel-loader.d.ts new file mode 100644 index 00000000..49fbff8b --- /dev/null +++ b/artifacts/build-angular/src/babel/babel-loader.d.ts @@ -0,0 +1,34 @@ +/** + * @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 + */ + +declare module 'babel-loader' { + type BabelLoaderCustomizer = (babel: typeof import('@babel/core')) => { + customOptions?( + this: import('webpack').loader.LoaderContext, + loaderOptions: Record, + loaderArguments: { source: string; map?: unknown }, + ): Promise<{ custom?: T; loader: Record }>; + config?( + this: import('webpack').loader.LoaderContext, + configuration: import('@babel/core').PartialConfig, + loaderArguments: { source: string; map?: unknown; customOptions: T }, + ): import('@babel/core').TransformOptions; + result?( + this: import('webpack').loader.LoaderContext, + result: import('@babel/core').BabelFileResult, + context: { + source: string; + map?: unknown; + customOptions: T; + configuration: import('@babel/core').PartialConfig; + options: import('@babel/core').TransformOptions; + }, + ): import('@babel/core').BabelFileResult; + }; + function custom(customizer: BabelLoaderCustomizer): import('webpack').loader.Loader; +} diff --git a/artifacts/build-angular/src/babel/plugins/adjust-static-class-members.d.ts b/artifacts/build-angular/src/babel/plugins/adjust-static-class-members.d.ts new file mode 100644 index 00000000..00f1d814 --- /dev/null +++ b/artifacts/build-angular/src/babel/plugins/adjust-static-class-members.d.ts @@ -0,0 +1,25 @@ +/** + * @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 { PluginObj } from '@babel/core'; +/** + * Provides one or more keywords that if found within the content of a source file indicate + * that this plugin should be used with a source file. + * + * @returns An a string iterable containing one or more keywords. + */ +export declare function getKeywords(): Iterable; +/** + * A babel plugin factory function for adjusting classes; primarily with Angular metadata. + * The adjustments include wrapping classes with known safe or no side effects with pure + * annotations to support dead code removal of unused classes. Angular compiler generated + * metadata static fields not required in AOT mode are also elided to better support bundler- + * level treeshaking. + * + * @returns A babel plugin object instance. + */ +export default function (): PluginObj; diff --git a/artifacts/build-angular/src/babel/plugins/adjust-static-class-members.js b/artifacts/build-angular/src/babel/plugins/adjust-static-class-members.js new file mode 100644 index 00000000..ba62ed62 --- /dev/null +++ b/artifacts/build-angular/src/babel/plugins/adjust-static-class-members.js @@ -0,0 +1,354 @@ +"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 __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getKeywords = void 0; +const core_1 = require("@babel/core"); +const helper_annotate_as_pure_1 = __importDefault(require("@babel/helper-annotate-as-pure")); +const helper_split_export_declaration_1 = __importDefault(require("@babel/helper-split-export-declaration")); +/** + * The name of the Typescript decorator helper function created by the TypeScript compiler. + */ +const TSLIB_DECORATE_HELPER_NAME = '__decorate'; +/** + * The set of Angular static fields that should always be wrapped. + * These fields may appear to have side effects but are safe to remove if the associated class + * is otherwise unused within the output. + */ +const angularStaticsToWrap = new Set([ + 'ɵcmp', + 'ɵdir', + 'ɵfac', + 'ɵinj', + 'ɵmod', + 'ɵpipe', + 'ɵprov', + 'INJECTOR_KEY', +]); +/** + * An object map of static fields and related value checks for discovery of Angular generated + * JIT related static fields. + */ +const angularStaticsToElide = { + 'ctorParameters'(path) { + return path.isFunctionExpression() || path.isArrowFunctionExpression(); + }, + 'decorators'(path) { + return path.isArrayExpression(); + }, + 'propDecorators'(path) { + return path.isObjectExpression(); + }, +}; +/** + * Provides one or more keywords that if found within the content of a source file indicate + * that this plugin should be used with a source file. + * + * @returns An a string iterable containing one or more keywords. + */ +function getKeywords() { + return ['class']; +} +exports.getKeywords = getKeywords; +/** + * Determines whether a property and its initializer value can be safely wrapped in a pure + * annotated IIFE. Values that may cause side effects are not considered safe to wrap. + * Wrapping such values may cause runtime errors and/or incorrect runtime behavior. + * + * @param propertyName The name of the property to analyze. + * @param assignmentValue The initializer value that will be assigned to the property. + * @returns If the property can be safely wrapped, then true; otherwise, false. + */ +function canWrapProperty(propertyName, assignmentValue) { + if (angularStaticsToWrap.has(propertyName)) { + return true; + } + const { leadingComments } = assignmentValue.node; + if (leadingComments?.some( + // `@pureOrBreakMyCode` is used by closure and is present in Angular code + ({ value }) => value.includes('@__PURE__') || + value.includes('#__PURE__') || + value.includes('@pureOrBreakMyCode'))) { + return true; + } + return assignmentValue.isPure(); +} +/** + * Analyze the sibling nodes of a class to determine if any downlevel elements should be + * wrapped in a pure annotated IIFE. Also determines if any elements have potential side + * effects. + * + * @param origin The starting NodePath location for analyzing siblings. + * @param classIdentifier The identifier node that represents the name of the class. + * @param allowWrappingDecorators Whether to allow decorators to be wrapped. + * @returns An object containing the results of the analysis. + */ +function analyzeClassSiblings(origin, classIdentifier, allowWrappingDecorators) { + const wrapStatementPaths = []; + let hasPotentialSideEffects = false; + for (let i = 1;; ++i) { + const nextStatement = origin.getSibling(+origin.key + i); + if (!nextStatement.isExpressionStatement()) { + break; + } + // Valid sibling statements for class declarations are only assignment expressions + // and TypeScript decorator helper call expressions + const nextExpression = nextStatement.get('expression'); + if (nextExpression.isCallExpression()) { + if (!core_1.types.isIdentifier(nextExpression.node.callee) || + nextExpression.node.callee.name !== TSLIB_DECORATE_HELPER_NAME) { + break; + } + if (allowWrappingDecorators) { + wrapStatementPaths.push(nextStatement); + } + else { + // Statement cannot be safely wrapped which makes wrapping the class unneeded. + // The statement will prevent even a wrapped class from being optimized away. + hasPotentialSideEffects = true; + } + continue; + } + else if (!nextExpression.isAssignmentExpression()) { + break; + } + // Valid assignment expressions should be member access expressions using the class + // name as the object and an identifier as the property for static fields or only + // the class name for decorators. + const left = nextExpression.get('left'); + if (left.isIdentifier()) { + if (!left.scope.bindingIdentifierEquals(left.node.name, classIdentifier) || + !core_1.types.isCallExpression(nextExpression.node.right) || + !core_1.types.isIdentifier(nextExpression.node.right.callee) || + nextExpression.node.right.callee.name !== TSLIB_DECORATE_HELPER_NAME) { + break; + } + if (allowWrappingDecorators) { + wrapStatementPaths.push(nextStatement); + } + else { + // Statement cannot be safely wrapped which makes wrapping the class unneeded. + // The statement will prevent even a wrapped class from being optimized away. + hasPotentialSideEffects = true; + } + continue; + } + else if (!left.isMemberExpression() || + !core_1.types.isIdentifier(left.node.object) || + !left.scope.bindingIdentifierEquals(left.node.object.name, classIdentifier) || + !core_1.types.isIdentifier(left.node.property)) { + break; + } + const propertyName = left.node.property.name; + const assignmentValue = nextExpression.get('right'); + if (angularStaticsToElide[propertyName]?.(assignmentValue)) { + nextStatement.remove(); + --i; + } + else if (canWrapProperty(propertyName, assignmentValue)) { + wrapStatementPaths.push(nextStatement); + } + else { + // Statement cannot be safely wrapped which makes wrapping the class unneeded. + // The statement will prevent even a wrapped class from being optimized away. + hasPotentialSideEffects = true; + } + } + return { hasPotentialSideEffects, wrapStatementPaths }; +} +/** + * The set of classes already visited and analyzed during the plugin's execution. + * This is used to prevent adjusted classes from being repeatedly analyzed which can lead + * to an infinite loop. + */ +const visitedClasses = new WeakSet(); +/** + * A map of classes that have already been analyzed during the default export splitting step. + * This is used to avoid analyzing a class declaration twice if it is a direct default export. + */ +const exportDefaultAnalysis = new WeakMap(); +/** + * A babel plugin factory function for adjusting classes; primarily with Angular metadata. + * The adjustments include wrapping classes with known safe or no side effects with pure + * annotations to support dead code removal of unused classes. Angular compiler generated + * metadata static fields not required in AOT mode are also elided to better support bundler- + * level treeshaking. + * + * @returns A babel plugin object instance. + */ +// eslint-disable-next-line max-lines-per-function +function default_1() { + return { + visitor: { + // When a class is converted to a variable declaration, the default export must be moved + // to a subsequent statement to prevent a JavaScript syntax error. + ExportDefaultDeclaration(path, state) { + const declaration = path.get('declaration'); + if (!declaration.isClassDeclaration()) { + return; + } + const { wrapDecorators } = state.opts; + const analysis = analyzeClassSiblings(path, declaration.node.id, wrapDecorators); + exportDefaultAnalysis.set(declaration.node, analysis); + // Splitting the export declaration is not needed if the class will not be wrapped + if (analysis.hasPotentialSideEffects) { + return; + } + (0, helper_split_export_declaration_1.default)(path); + }, + ClassDeclaration(path, state) { + const { node: classNode, parentPath } = path; + const { wrapDecorators } = state.opts; + if (visitedClasses.has(classNode)) { + return; + } + // Analyze sibling statements for elements of the class that were downleveled + const origin = parentPath.isExportNamedDeclaration() ? parentPath : path; + const { wrapStatementPaths, hasPotentialSideEffects } = exportDefaultAnalysis.get(classNode) ?? + analyzeClassSiblings(origin, classNode.id, wrapDecorators); + visitedClasses.add(classNode); + if (hasPotentialSideEffects) { + return; + } + // If no statements to wrap, check for static class properties. + // Static class properties may be downleveled at later stages in the build pipeline + // which results in additional function calls outside the class body. These calls + // then cause the class to be referenced and not eligible for removal. Since it is + // not known at this stage whether the class needs to be downleveled, the transform + // wraps classes preemptively to allow for potential removal within the optimization + // stages. + if (wrapStatementPaths.length === 0) { + let shouldWrap = false; + for (const element of path.get('body').get('body')) { + if (element.isClassProperty()) { + // Only need to analyze static properties + if (!element.node.static) { + continue; + } + // Check for potential side effects. + // These checks are conservative and could potentially be expanded in the future. + const elementKey = element.get('key'); + const elementValue = element.get('value'); + if (elementKey.isIdentifier() && + (!elementValue.isExpression() || + canWrapProperty(elementKey.node.name, elementValue))) { + shouldWrap = true; + } + else { + // Not safe to wrap + shouldWrap = false; + break; + } + // eslint-disable-next-line @typescript-eslint/no-explicit-any + } + else if (element.isStaticBlock()) { + // Only need to analyze static blocks + const body = element.get('body'); + if (Array.isArray(body) && body.length > 1) { + // Not safe to wrap + shouldWrap = false; + break; + } + const expression = body.find((n) => n.isExpressionStatement()); + const assignmentExpression = expression?.get('expression'); + if (assignmentExpression?.isAssignmentExpression()) { + const left = assignmentExpression.get('left'); + if (!left.isMemberExpression()) { + continue; + } + if (!left.get('object').isThisExpression()) { + // Not safe to wrap + shouldWrap = false; + break; + } + const element = left.get('property'); + const right = assignmentExpression.get('right'); + if (element.isIdentifier() && + (!right.isExpression() || canWrapProperty(element.node.name, right))) { + shouldWrap = true; + } + else { + // Not safe to wrap + shouldWrap = false; + break; + } + } + } + } + if (!shouldWrap) { + return; + } + } + const wrapStatementNodes = []; + for (const statementPath of wrapStatementPaths) { + wrapStatementNodes.push(statementPath.node); + statementPath.remove(); + } + // Wrap class and safe static assignments in a pure annotated IIFE + const container = core_1.types.arrowFunctionExpression([], core_1.types.blockStatement([ + classNode, + ...wrapStatementNodes, + core_1.types.returnStatement(core_1.types.cloneNode(classNode.id)), + ])); + const replacementInitializer = core_1.types.callExpression(core_1.types.parenthesizedExpression(container), []); + (0, helper_annotate_as_pure_1.default)(replacementInitializer); + // Replace class with IIFE wrapped class + const declaration = core_1.types.variableDeclaration('let', [ + core_1.types.variableDeclarator(core_1.types.cloneNode(classNode.id), replacementInitializer), + ]); + path.replaceWith(declaration); + }, + ClassExpression(path, state) { + const { node: classNode, parentPath } = path; + const { wrapDecorators } = state.opts; + // Class expressions are used by TypeScript to represent downlevel class/constructor decorators. + // If not wrapping decorators, they do not need to be processed. + if (!wrapDecorators || visitedClasses.has(classNode)) { + return; + } + if (!classNode.id || + !parentPath.isVariableDeclarator() || + !core_1.types.isIdentifier(parentPath.node.id) || + parentPath.node.id.name !== classNode.id.name) { + return; + } + const origin = parentPath.parentPath; + if (!origin.isVariableDeclaration() || origin.node.declarations.length !== 1) { + return; + } + const { wrapStatementPaths, hasPotentialSideEffects } = analyzeClassSiblings(origin, parentPath.node.id, wrapDecorators); + visitedClasses.add(classNode); + if (hasPotentialSideEffects || wrapStatementPaths.length === 0) { + return; + } + const wrapStatementNodes = []; + for (const statementPath of wrapStatementPaths) { + wrapStatementNodes.push(statementPath.node); + statementPath.remove(); + } + // Wrap class and safe static assignments in a pure annotated IIFE + const container = core_1.types.arrowFunctionExpression([], core_1.types.blockStatement([ + core_1.types.variableDeclaration('let', [ + core_1.types.variableDeclarator(core_1.types.cloneNode(classNode.id), classNode), + ]), + ...wrapStatementNodes, + core_1.types.returnStatement(core_1.types.cloneNode(classNode.id)), + ])); + const replacementInitializer = core_1.types.callExpression(core_1.types.parenthesizedExpression(container), []); + (0, helper_annotate_as_pure_1.default)(replacementInitializer); + // Add the wrapped class directly to the variable declaration + parentPath.get('init').replaceWith(replacementInitializer); + }, + }, + }; +} +exports.default = default_1; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"adjust-static-class-members.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/babel/plugins/adjust-static-class-members.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 { NodePath, PluginObj, PluginPass, types } from '@babel/core';\nimport annotateAsPure from '@babel/helper-annotate-as-pure';\nimport splitExportDeclaration from '@babel/helper-split-export-declaration';\n\n/**\n * The name of the Typescript decorator helper function created by the TypeScript compiler.\n */\nconst TSLIB_DECORATE_HELPER_NAME = '__decorate';\n\n/**\n * The set of Angular static fields that should always be wrapped.\n * These fields may appear to have side effects but are safe to remove if the associated class\n * is otherwise unused within the output.\n */\nconst angularStaticsToWrap = new Set([\n  'ɵcmp',\n  'ɵdir',\n  'ɵfac',\n  'ɵinj',\n  'ɵmod',\n  'ɵpipe',\n  'ɵprov',\n  'INJECTOR_KEY',\n]);\n\n/**\n * An object map of static fields and related value checks for discovery of Angular generated\n * JIT related static fields.\n */\nconst angularStaticsToElide: Record<string, (path: NodePath<types.Expression>) => boolean> = {\n  'ctorParameters'(path) {\n    return path.isFunctionExpression() || path.isArrowFunctionExpression();\n  },\n  'decorators'(path) {\n    return path.isArrayExpression();\n  },\n  'propDecorators'(path) {\n    return path.isObjectExpression();\n  },\n};\n\n/**\n * Provides one or more keywords that if found within the content of a source file indicate\n * that this plugin should be used with a source file.\n *\n * @returns An a string iterable containing one or more keywords.\n */\nexport function getKeywords(): Iterable<string> {\n  return ['class'];\n}\n\n/**\n * Determines whether a property and its initializer value can be safely wrapped in a pure\n * annotated IIFE. Values that may cause side effects are not considered safe to wrap.\n * Wrapping such values may cause runtime errors and/or incorrect runtime behavior.\n *\n * @param propertyName The name of the property to analyze.\n * @param assignmentValue The initializer value that will be assigned to the property.\n * @returns If the property can be safely wrapped, then true; otherwise, false.\n */\nfunction canWrapProperty(propertyName: string, assignmentValue: NodePath): boolean {\n  if (angularStaticsToWrap.has(propertyName)) {\n    return true;\n  }\n\n  const { leadingComments } = assignmentValue.node as { leadingComments?: { value: string }[] };\n  if (\n    leadingComments?.some(\n      // `@pureOrBreakMyCode` is used by closure and is present in Angular code\n      ({ value }) =>\n        value.includes('@__PURE__') ||\n        value.includes('#__PURE__') ||\n        value.includes('@pureOrBreakMyCode'),\n    )\n  ) {\n    return true;\n  }\n\n  return assignmentValue.isPure();\n}\n\n/**\n * Analyze the sibling nodes of a class to determine if any downlevel elements should be\n * wrapped in a pure annotated IIFE. Also determines if any elements have potential side\n * effects.\n *\n * @param origin The starting NodePath location for analyzing siblings.\n * @param classIdentifier The identifier node that represents the name of the class.\n * @param allowWrappingDecorators Whether to allow decorators to be wrapped.\n * @returns An object containing the results of the analysis.\n */\nfunction analyzeClassSiblings(\n  origin: NodePath,\n  classIdentifier: types.Identifier,\n  allowWrappingDecorators: boolean,\n): { hasPotentialSideEffects: boolean; wrapStatementPaths: NodePath<types.Statement>[] } {\n  const wrapStatementPaths: NodePath<types.Statement>[] = [];\n  let hasPotentialSideEffects = false;\n  for (let i = 1; ; ++i) {\n    const nextStatement = origin.getSibling(+origin.key + i);\n    if (!nextStatement.isExpressionStatement()) {\n      break;\n    }\n\n    // Valid sibling statements for class declarations are only assignment expressions\n    // and TypeScript decorator helper call expressions\n    const nextExpression = nextStatement.get('expression');\n    if (nextExpression.isCallExpression()) {\n      if (\n        !types.isIdentifier(nextExpression.node.callee) ||\n        nextExpression.node.callee.name !== TSLIB_DECORATE_HELPER_NAME\n      ) {\n        break;\n      }\n\n      if (allowWrappingDecorators) {\n        wrapStatementPaths.push(nextStatement);\n      } else {\n        // Statement cannot be safely wrapped which makes wrapping the class unneeded.\n        // The statement will prevent even a wrapped class from being optimized away.\n        hasPotentialSideEffects = true;\n      }\n\n      continue;\n    } else if (!nextExpression.isAssignmentExpression()) {\n      break;\n    }\n\n    // Valid assignment expressions should be member access expressions using the class\n    // name as the object and an identifier as the property for static fields or only\n    // the class name for decorators.\n    const left = nextExpression.get('left');\n    if (left.isIdentifier()) {\n      if (\n        !left.scope.bindingIdentifierEquals(left.node.name, classIdentifier) ||\n        !types.isCallExpression(nextExpression.node.right) ||\n        !types.isIdentifier(nextExpression.node.right.callee) ||\n        nextExpression.node.right.callee.name !== TSLIB_DECORATE_HELPER_NAME\n      ) {\n        break;\n      }\n\n      if (allowWrappingDecorators) {\n        wrapStatementPaths.push(nextStatement);\n      } else {\n        // Statement cannot be safely wrapped which makes wrapping the class unneeded.\n        // The statement will prevent even a wrapped class from being optimized away.\n        hasPotentialSideEffects = true;\n      }\n\n      continue;\n    } else if (\n      !left.isMemberExpression() ||\n      !types.isIdentifier(left.node.object) ||\n      !left.scope.bindingIdentifierEquals(left.node.object.name, classIdentifier) ||\n      !types.isIdentifier(left.node.property)\n    ) {\n      break;\n    }\n\n    const propertyName = left.node.property.name;\n    const assignmentValue = nextExpression.get('right');\n    if (angularStaticsToElide[propertyName]?.(assignmentValue)) {\n      nextStatement.remove();\n      --i;\n    } else if (canWrapProperty(propertyName, assignmentValue)) {\n      wrapStatementPaths.push(nextStatement);\n    } else {\n      // Statement cannot be safely wrapped which makes wrapping the class unneeded.\n      // The statement will prevent even a wrapped class from being optimized away.\n      hasPotentialSideEffects = true;\n    }\n  }\n\n  return { hasPotentialSideEffects, wrapStatementPaths };\n}\n\n/**\n * The set of classes already visited and analyzed during the plugin's execution.\n * This is used to prevent adjusted classes from being repeatedly analyzed which can lead\n * to an infinite loop.\n */\nconst visitedClasses = new WeakSet<types.Class>();\n\n/**\n * A map of classes that have already been analyzed during the default export splitting step.\n * This is used to avoid analyzing a class declaration twice if it is a direct default export.\n */\nconst exportDefaultAnalysis = new WeakMap<types.Class, ReturnType<typeof analyzeClassSiblings>>();\n\n/**\n * A babel plugin factory function for adjusting classes; primarily with Angular metadata.\n * The adjustments include wrapping classes with known safe or no side effects with pure\n * annotations to support dead code removal of unused classes. Angular compiler generated\n * metadata static fields not required in AOT mode are also elided to better support bundler-\n * level treeshaking.\n *\n * @returns A babel plugin object instance.\n */\n// eslint-disable-next-line max-lines-per-function\nexport default function (): PluginObj {\n  return {\n    visitor: {\n      // When a class is converted to a variable declaration, the default export must be moved\n      // to a subsequent statement to prevent a JavaScript syntax error.\n      ExportDefaultDeclaration(path: NodePath<types.ExportDefaultDeclaration>, state: PluginPass) {\n        const declaration = path.get('declaration');\n        if (!declaration.isClassDeclaration()) {\n          return;\n        }\n\n        const { wrapDecorators } = state.opts as { wrapDecorators: boolean };\n        const analysis = analyzeClassSiblings(path, declaration.node.id, wrapDecorators);\n        exportDefaultAnalysis.set(declaration.node, analysis);\n\n        // Splitting the export declaration is not needed if the class will not be wrapped\n        if (analysis.hasPotentialSideEffects) {\n          return;\n        }\n\n        splitExportDeclaration(path);\n      },\n      ClassDeclaration(path: NodePath<types.ClassDeclaration>, state: PluginPass) {\n        const { node: classNode, parentPath } = path;\n        const { wrapDecorators } = state.opts as { wrapDecorators: boolean };\n\n        if (visitedClasses.has(classNode)) {\n          return;\n        }\n\n        // Analyze sibling statements for elements of the class that were downleveled\n        const origin = parentPath.isExportNamedDeclaration() ? parentPath : path;\n        const { wrapStatementPaths, hasPotentialSideEffects } =\n          exportDefaultAnalysis.get(classNode) ??\n          analyzeClassSiblings(origin, classNode.id, wrapDecorators);\n\n        visitedClasses.add(classNode);\n\n        if (hasPotentialSideEffects) {\n          return;\n        }\n\n        // If no statements to wrap, check for static class properties.\n        // Static class properties may be downleveled at later stages in the build pipeline\n        // which results in additional function calls outside the class body. These calls\n        // then cause the class to be referenced and not eligible for removal. Since it is\n        // not known at this stage whether the class needs to be downleveled, the transform\n        // wraps classes preemptively to allow for potential removal within the optimization\n        // stages.\n        if (wrapStatementPaths.length === 0) {\n          let shouldWrap = false;\n          for (const element of path.get('body').get('body')) {\n            if (element.isClassProperty()) {\n              // Only need to analyze static properties\n              if (!element.node.static) {\n                continue;\n              }\n\n              // Check for potential side effects.\n              // These checks are conservative and could potentially be expanded in the future.\n              const elementKey = element.get('key');\n              const elementValue = element.get('value');\n              if (\n                elementKey.isIdentifier() &&\n                (!elementValue.isExpression() ||\n                  canWrapProperty(elementKey.node.name, elementValue))\n              ) {\n                shouldWrap = true;\n              } else {\n                // Not safe to wrap\n                shouldWrap = false;\n                break;\n              }\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            } else if ((element as any).isStaticBlock()) {\n              // Only need to analyze static blocks\n              const body = element.get('body');\n\n              if (Array.isArray(body) && body.length > 1) {\n                // Not safe to wrap\n                shouldWrap = false;\n                break;\n              }\n\n              const expression = body.find((n: NodePath<types.Node>) =>\n                n.isExpressionStatement(),\n              ) as NodePath<types.ExpressionStatement> | undefined;\n\n              const assignmentExpression = expression?.get('expression');\n              if (assignmentExpression?.isAssignmentExpression()) {\n                const left = assignmentExpression.get('left');\n                if (!left.isMemberExpression()) {\n                  continue;\n                }\n\n                if (!left.get('object').isThisExpression()) {\n                  // Not safe to wrap\n                  shouldWrap = false;\n                  break;\n                }\n\n                const element = left.get('property');\n                const right = assignmentExpression.get('right');\n                if (\n                  element.isIdentifier() &&\n                  (!right.isExpression() || canWrapProperty(element.node.name, right))\n                ) {\n                  shouldWrap = true;\n                } else {\n                  // Not safe to wrap\n                  shouldWrap = false;\n                  break;\n                }\n              }\n            }\n          }\n          if (!shouldWrap) {\n            return;\n          }\n        }\n\n        const wrapStatementNodes: types.Statement[] = [];\n        for (const statementPath of wrapStatementPaths) {\n          wrapStatementNodes.push(statementPath.node);\n          statementPath.remove();\n        }\n\n        // Wrap class and safe static assignments in a pure annotated IIFE\n        const container = types.arrowFunctionExpression(\n          [],\n          types.blockStatement([\n            classNode,\n            ...wrapStatementNodes,\n            types.returnStatement(types.cloneNode(classNode.id)),\n          ]),\n        );\n        const replacementInitializer = types.callExpression(\n          types.parenthesizedExpression(container),\n          [],\n        );\n        annotateAsPure(replacementInitializer);\n\n        // Replace class with IIFE wrapped class\n        const declaration = types.variableDeclaration('let', [\n          types.variableDeclarator(types.cloneNode(classNode.id), replacementInitializer),\n        ]);\n        path.replaceWith(declaration);\n      },\n      ClassExpression(path: NodePath<types.ClassExpression>, state: PluginPass) {\n        const { node: classNode, parentPath } = path;\n        const { wrapDecorators } = state.opts as { wrapDecorators: boolean };\n\n        // Class expressions are used by TypeScript to represent downlevel class/constructor decorators.\n        // If not wrapping decorators, they do not need to be processed.\n        if (!wrapDecorators || visitedClasses.has(classNode)) {\n          return;\n        }\n\n        if (\n          !classNode.id ||\n          !parentPath.isVariableDeclarator() ||\n          !types.isIdentifier(parentPath.node.id) ||\n          parentPath.node.id.name !== classNode.id.name\n        ) {\n          return;\n        }\n\n        const origin = parentPath.parentPath;\n        if (!origin.isVariableDeclaration() || origin.node.declarations.length !== 1) {\n          return;\n        }\n\n        const { wrapStatementPaths, hasPotentialSideEffects } = analyzeClassSiblings(\n          origin,\n          parentPath.node.id,\n          wrapDecorators,\n        );\n\n        visitedClasses.add(classNode);\n\n        if (hasPotentialSideEffects || wrapStatementPaths.length === 0) {\n          return;\n        }\n\n        const wrapStatementNodes: types.Statement[] = [];\n        for (const statementPath of wrapStatementPaths) {\n          wrapStatementNodes.push(statementPath.node);\n          statementPath.remove();\n        }\n\n        // Wrap class and safe static assignments in a pure annotated IIFE\n        const container = types.arrowFunctionExpression(\n          [],\n          types.blockStatement([\n            types.variableDeclaration('let', [\n              types.variableDeclarator(types.cloneNode(classNode.id), classNode),\n            ]),\n            ...wrapStatementNodes,\n            types.returnStatement(types.cloneNode(classNode.id)),\n          ]),\n        );\n        const replacementInitializer = types.callExpression(\n          types.parenthesizedExpression(container),\n          [],\n        );\n        annotateAsPure(replacementInitializer);\n\n        // Add the wrapped class directly to the variable declaration\n        parentPath.get('init').replaceWith(replacementInitializer);\n      },\n    },\n  };\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/babel/plugins/adjust-typescript-enums.d.ts b/artifacts/build-angular/src/babel/plugins/adjust-typescript-enums.d.ts new file mode 100644 index 00000000..420a16fc --- /dev/null +++ b/artifacts/build-angular/src/babel/plugins/adjust-typescript-enums.d.ts @@ -0,0 +1,21 @@ +/** + * @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 { PluginObj } from '@babel/core'; +/** + * Provides one or more keywords that if found within the content of a source file indicate + * that this plugin should be used with a source file. + * + * @returns An a string iterable containing one or more keywords. + */ +export declare function getKeywords(): Iterable; +/** + * A babel plugin factory function for adjusting TypeScript emitted enums. + * + * @returns A babel plugin object instance. + */ +export default function (): PluginObj; diff --git a/artifacts/build-angular/src/babel/plugins/adjust-typescript-enums.js b/artifacts/build-angular/src/babel/plugins/adjust-typescript-enums.js new file mode 100644 index 00000000..3cf015ce --- /dev/null +++ b/artifacts/build-angular/src/babel/plugins/adjust-typescript-enums.js @@ -0,0 +1,124 @@ +"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 __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getKeywords = void 0; +const core_1 = require("@babel/core"); +const helper_annotate_as_pure_1 = __importDefault(require("@babel/helper-annotate-as-pure")); +/** + * Provides one or more keywords that if found within the content of a source file indicate + * that this plugin should be used with a source file. + * + * @returns An a string iterable containing one or more keywords. + */ +function getKeywords() { + return ['var']; +} +exports.getKeywords = getKeywords; +/** + * A babel plugin factory function for adjusting TypeScript emitted enums. + * + * @returns A babel plugin object instance. + */ +function default_1() { + return { + visitor: { + VariableDeclaration(path) { + const { parentPath, node } = path; + if (node.kind !== 'var' || node.declarations.length !== 1) { + return; + } + const declaration = path.get('declarations')[0]; + if (declaration.node.init) { + return; + } + const declarationId = declaration.node.id; + if (!core_1.types.isIdentifier(declarationId)) { + return; + } + const hasExport = parentPath.isExportNamedDeclaration() || parentPath.isExportDefaultDeclaration(); + const origin = hasExport ? parentPath : path; + const nextStatement = origin.getSibling(+origin.key + 1); + if (!nextStatement.isExpressionStatement()) { + return; + } + const nextExpression = nextStatement.get('expression'); + if (!nextExpression.isCallExpression() || nextExpression.node.arguments.length !== 1) { + return; + } + const enumCallArgument = nextExpression.node.arguments[0]; + if (!core_1.types.isLogicalExpression(enumCallArgument, { operator: '||' })) { + return; + } + // Check if identifiers match var declaration + if (!core_1.types.isIdentifier(enumCallArgument.left) || + !nextExpression.scope.bindingIdentifierEquals(enumCallArgument.left.name, declarationId)) { + return; + } + const enumCallee = nextExpression.get('callee'); + if (!enumCallee.isFunctionExpression() || enumCallee.node.params.length !== 1) { + return; + } + const enumCalleeParam = enumCallee.node.params[0]; + const isEnumCalleeMatching = core_1.types.isIdentifier(enumCalleeParam) && enumCalleeParam.name === declarationId.name; + let enumAssignments; + if (isEnumCalleeMatching) { + enumAssignments = []; + } + // Check if all enum member values are pure. + // If not, leave as-is due to potential side efects + let hasElements = false; + for (const enumStatement of enumCallee.get('body').get('body')) { + if (!enumStatement.isExpressionStatement()) { + return; + } + const enumValueAssignment = enumStatement.get('expression'); + if (!enumValueAssignment.isAssignmentExpression() || + !enumValueAssignment.get('right').isPure()) { + return; + } + hasElements = true; + enumAssignments?.push(enumStatement.node); + } + // If there are no enum elements then there is nothing to wrap + if (!hasElements) { + return; + } + // Remove existing enum initializer + const enumInitializer = nextExpression.node; + nextExpression.remove(); + // Create IIFE block contents + let blockContents; + if (enumAssignments) { + // Loose mode + blockContents = [ + core_1.types.expressionStatement(core_1.types.assignmentExpression('=', core_1.types.cloneNode(declarationId), core_1.types.logicalExpression('||', core_1.types.cloneNode(declarationId), core_1.types.objectExpression([])))), + ...enumAssignments, + ]; + } + else { + blockContents = [core_1.types.expressionStatement(enumInitializer)]; + } + // Wrap existing enum initializer in a pure annotated IIFE + const container = core_1.types.arrowFunctionExpression([], core_1.types.blockStatement([ + ...blockContents, + core_1.types.returnStatement(core_1.types.cloneNode(declarationId)), + ])); + const replacementInitializer = core_1.types.callExpression(core_1.types.parenthesizedExpression(container), []); + (0, helper_annotate_as_pure_1.default)(replacementInitializer); + // Add the wrapped enum initializer directly to the variable declaration + declaration.get('init').replaceWith(replacementInitializer); + }, + }, + }; +} +exports.default = default_1; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"adjust-typescript-enums.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/babel/plugins/adjust-typescript-enums.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 { NodePath, PluginObj, types } from '@babel/core';\nimport annotateAsPure from '@babel/helper-annotate-as-pure';\n\n/**\n * Provides one or more keywords that if found within the content of a source file indicate\n * that this plugin should be used with a source file.\n *\n * @returns An a string iterable containing one or more keywords.\n */\nexport function getKeywords(): Iterable<string> {\n  return ['var'];\n}\n\n/**\n * A babel plugin factory function for adjusting TypeScript emitted enums.\n *\n * @returns A babel plugin object instance.\n */\nexport default function (): PluginObj {\n  return {\n    visitor: {\n      VariableDeclaration(path: NodePath<types.VariableDeclaration>) {\n        const { parentPath, node } = path;\n        if (node.kind !== 'var' || node.declarations.length !== 1) {\n          return;\n        }\n\n        const declaration = path.get('declarations')[0];\n        if (declaration.node.init) {\n          return;\n        }\n\n        const declarationId = declaration.node.id;\n        if (!types.isIdentifier(declarationId)) {\n          return;\n        }\n\n        const hasExport =\n          parentPath.isExportNamedDeclaration() || parentPath.isExportDefaultDeclaration();\n        const origin = hasExport ? parentPath : path;\n        const nextStatement = origin.getSibling(+origin.key + 1);\n        if (!nextStatement.isExpressionStatement()) {\n          return;\n        }\n\n        const nextExpression = nextStatement.get('expression');\n        if (!nextExpression.isCallExpression() || nextExpression.node.arguments.length !== 1) {\n          return;\n        }\n\n        const enumCallArgument = nextExpression.node.arguments[0];\n        if (!types.isLogicalExpression(enumCallArgument, { operator: '||' })) {\n          return;\n        }\n\n        // Check if identifiers match var declaration\n        if (\n          !types.isIdentifier(enumCallArgument.left) ||\n          !nextExpression.scope.bindingIdentifierEquals(enumCallArgument.left.name, declarationId)\n        ) {\n          return;\n        }\n\n        const enumCallee = nextExpression.get('callee');\n        if (!enumCallee.isFunctionExpression() || enumCallee.node.params.length !== 1) {\n          return;\n        }\n\n        const enumCalleeParam = enumCallee.node.params[0];\n        const isEnumCalleeMatching =\n          types.isIdentifier(enumCalleeParam) && enumCalleeParam.name === declarationId.name;\n\n        let enumAssignments: types.ExpressionStatement[] | undefined;\n        if (isEnumCalleeMatching) {\n          enumAssignments = [];\n        }\n\n        // Check if all enum member values are pure.\n        // If not, leave as-is due to potential side efects\n        let hasElements = false;\n        for (const enumStatement of enumCallee.get('body').get('body')) {\n          if (!enumStatement.isExpressionStatement()) {\n            return;\n          }\n\n          const enumValueAssignment = enumStatement.get('expression');\n          if (\n            !enumValueAssignment.isAssignmentExpression() ||\n            !enumValueAssignment.get('right').isPure()\n          ) {\n            return;\n          }\n\n          hasElements = true;\n          enumAssignments?.push(enumStatement.node);\n        }\n\n        // If there are no enum elements then there is nothing to wrap\n        if (!hasElements) {\n          return;\n        }\n\n        // Remove existing enum initializer\n        const enumInitializer = nextExpression.node;\n        nextExpression.remove();\n\n        // Create IIFE block contents\n        let blockContents;\n        if (enumAssignments) {\n          // Loose mode\n          blockContents = [\n            types.expressionStatement(\n              types.assignmentExpression(\n                '=',\n                types.cloneNode(declarationId),\n                types.logicalExpression(\n                  '||',\n                  types.cloneNode(declarationId),\n                  types.objectExpression([]),\n                ),\n              ),\n            ),\n            ...enumAssignments,\n          ];\n        } else {\n          blockContents = [types.expressionStatement(enumInitializer)];\n        }\n\n        // Wrap existing enum initializer in a pure annotated IIFE\n        const container = types.arrowFunctionExpression(\n          [],\n          types.blockStatement([\n            ...blockContents,\n            types.returnStatement(types.cloneNode(declarationId)),\n          ]),\n        );\n        const replacementInitializer = types.callExpression(\n          types.parenthesizedExpression(container),\n          [],\n        );\n        annotateAsPure(replacementInitializer);\n\n        // Add the wrapped enum initializer directly to the variable declaration\n        declaration.get('init').replaceWith(replacementInitializer);\n      },\n    },\n  };\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/babel/plugins/elide-angular-metadata.d.ts b/artifacts/build-angular/src/babel/plugins/elide-angular-metadata.d.ts new file mode 100644 index 00000000..df69b57a --- /dev/null +++ b/artifacts/build-angular/src/babel/plugins/elide-angular-metadata.d.ts @@ -0,0 +1,21 @@ +/** + * @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 { PluginObj } from '@babel/core'; +/** + * Provides one or more keywords that if found within the content of a source file indicate + * that this plugin should be used with a source file. + * + * @returns An a string iterable containing one or more keywords. + */ +export declare function getKeywords(): Iterable; +/** + * A babel plugin factory function for eliding the Angular class metadata function (`ɵsetClassMetadata`). + * + * @returns A babel plugin object instance. + */ +export default function (): PluginObj; diff --git a/artifacts/build-angular/src/babel/plugins/elide-angular-metadata.js b/artifacts/build-angular/src/babel/plugins/elide-angular-metadata.js new file mode 100644 index 00000000..c3cd1c4a --- /dev/null +++ b/artifacts/build-angular/src/babel/plugins/elide-angular-metadata.js @@ -0,0 +1,68 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getKeywords = void 0; +const core_1 = require("@babel/core"); +/** + * The name of the Angular class metadata function created by the Angular compiler. + */ +const SET_CLASS_METADATA_NAME = 'ɵsetClassMetadata'; +/** + * Provides one or more keywords that if found within the content of a source file indicate + * that this plugin should be used with a source file. + * + * @returns An a string iterable containing one or more keywords. + */ +function getKeywords() { + return [SET_CLASS_METADATA_NAME]; +} +exports.getKeywords = getKeywords; +/** + * A babel plugin factory function for eliding the Angular class metadata function (`ɵsetClassMetadata`). + * + * @returns A babel plugin object instance. + */ +function default_1() { + return { + visitor: { + CallExpression(path) { + const callee = path.node.callee; + // The function being called must be the metadata function name + let calleeName; + if (core_1.types.isMemberExpression(callee) && core_1.types.isIdentifier(callee.property)) { + calleeName = callee.property.name; + } + else if (core_1.types.isIdentifier(callee)) { + calleeName = callee.name; + } + if (calleeName !== SET_CLASS_METADATA_NAME) { + return; + } + // There must be four arguments that meet the following criteria: + // * First must be an identifier + // * Second must be an array literal + const callArguments = path.node.arguments; + if (callArguments.length !== 4 || + !core_1.types.isIdentifier(callArguments[0]) || + !core_1.types.isArrayExpression(callArguments[1])) { + return; + } + // The metadata function is always emitted inside a function expression + if (!path.getFunctionParent()?.isFunctionExpression()) { + return; + } + // Replace the metadata function with `void 0` which is the equivalent return value + // of the metadata function. + path.replaceWith(path.scope.buildUndefinedNode()); + }, + }, + }; +} +exports.default = default_1; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/babel/plugins/pure-toplevel-functions.d.ts b/artifacts/build-angular/src/babel/plugins/pure-toplevel-functions.d.ts new file mode 100644 index 00000000..be0976ca --- /dev/null +++ b/artifacts/build-angular/src/babel/plugins/pure-toplevel-functions.d.ts @@ -0,0 +1,14 @@ +/** + * @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 { PluginObj } from '@babel/core'; +/** + * A babel plugin factory function for adding the PURE annotation to top-level new and call expressions. + * + * @returns A babel plugin object instance. + */ +export default function (): PluginObj; diff --git a/artifacts/build-angular/src/babel/plugins/pure-toplevel-functions.js b/artifacts/build-angular/src/babel/plugins/pure-toplevel-functions.js new file mode 100644 index 00000000..d0a3e4ec --- /dev/null +++ b/artifacts/build-angular/src/babel/plugins/pure-toplevel-functions.js @@ -0,0 +1,91 @@ +"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; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const core_1 = require("@babel/core"); +const helper_annotate_as_pure_1 = __importDefault(require("@babel/helper-annotate-as-pure")); +const tslib = __importStar(require("tslib")); +/** + * A cached set of TypeScript helper function names used by the helper name matcher utility function. + */ +const tslibHelpers = new Set(Object.keys(tslib).filter((h) => h.startsWith('__'))); +/** + * Determinates whether an identifier name matches one of the TypeScript helper function names. + * + * @param name The identifier name to check. + * @returns True, if the name matches a TypeScript helper name; otherwise, false. + */ +function isTslibHelperName(name) { + const nameParts = name.split('$'); + const originalName = nameParts[0]; + if (nameParts.length > 2 || (nameParts.length === 2 && isNaN(+nameParts[1]))) { + return false; + } + return tslibHelpers.has(originalName); +} +/** + * A babel plugin factory function for adding the PURE annotation to top-level new and call expressions. + * + * @returns A babel plugin object instance. + */ +function default_1() { + return { + visitor: { + CallExpression(path) { + // If the expression has a function parent, it is not top-level + if (path.getFunctionParent()) { + return; + } + const callee = path.node.callee; + if (core_1.types.isFunctionExpression(callee) && path.node.arguments.length !== 0) { + return; + } + // Do not annotate TypeScript helpers emitted by the TypeScript compiler. + // TypeScript helpers are intended to cause side effects. + if (core_1.types.isIdentifier(callee) && isTslibHelperName(callee.name)) { + return; + } + (0, helper_annotate_as_pure_1.default)(path); + }, + NewExpression(path) { + // If the expression has a function parent, it is not top-level + if (!path.getFunctionParent()) { + (0, helper_annotate_as_pure_1.default)(path); + } + }, + }, + }; +} +exports.default = default_1; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/babel/presets/application.d.ts b/artifacts/build-angular/src/babel/presets/application.d.ts new file mode 100644 index 00000000..1b3c7444 --- /dev/null +++ b/artifacts/build-angular/src/babel/presets/application.d.ts @@ -0,0 +1,49 @@ +/** + * @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 type { ɵParsedTranslation } from '@angular/localize'; +import type { makeEs2015TranslatePlugin, makeLocalePlugin } from '@angular/localize/tools'; +export type DiagnosticReporter = (type: 'error' | 'warning' | 'info', message: string) => void; +/** + * An interface representing the factory functions for the `@angular/localize` translation Babel plugins. + * This must be provided for the ESM imports since dynamic imports are required to be asynchronous and + * Babel presets currently can only be synchronous. + * + */ +export interface I18nPluginCreators { + makeEs2015TranslatePlugin: typeof makeEs2015TranslatePlugin; + makeLocalePlugin: typeof makeLocalePlugin; +} +export interface ApplicationPresetOptions { + i18n?: { + locale: string; + missingTranslationBehavior?: 'error' | 'warning' | 'ignore'; + translation?: Record; + translationFiles?: string[]; + pluginCreators: I18nPluginCreators; + }; + angularLinker?: { + shouldLink: boolean; + jitMode: boolean; + linkerPluginCreator: typeof import('@angular/compiler-cli/linker/babel').createEs2015LinkerPlugin; + }; + forceAsyncTransformation?: boolean; + instrumentCode?: { + includedBasePath: string; + inputSourceMap: unknown; + }; + optimize?: { + pureTopLevel: boolean; + wrapDecorators: boolean; + }; + supportedBrowsers?: string[]; + diagnosticReporter?: DiagnosticReporter; +} +export default function (api: unknown, options: ApplicationPresetOptions): { + presets: any[][]; + plugins: any[]; +}; diff --git a/artifacts/build-angular/src/babel/presets/application.js b/artifacts/build-angular/src/babel/presets/application.js new file mode 100644 index 00000000..5138e0db --- /dev/null +++ b/artifacts/build-angular/src/babel/presets/application.js @@ -0,0 +1,197 @@ +"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; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const assert_1 = require("assert"); +const browserslist_1 = __importDefault(require("browserslist")); +const fs = __importStar(require("fs")); +const path = __importStar(require("path")); +/** + * List of browsers which are affected by a WebKit bug where class field + * initializers might have incorrect variable scopes. + * + * See: https://github.com/angular/angular-cli/issues/24355#issuecomment-1333477033 + * See: https://github.com/WebKit/WebKit/commit/e8788a34b3d5f5b4edd7ff6450b80936bff396f2 + */ +const safariClassFieldScopeBugBrowsers = new Set((0, browserslist_1.default)([ + // Safari <15 is technically not supported via https://angular.io/guide/browser-support, + // but we apply the workaround if forcibly selected. + 'Safari <=15', + 'iOS <=15', +])); +function createI18nDiagnostics(reporter) { + const diagnostics = new (class { + constructor() { + this.messages = []; + this.hasErrors = false; + } + add(type, message) { + if (type === 'ignore') { + return; + } + this.messages.push({ type, message }); + this.hasErrors || (this.hasErrors = type === 'error'); + reporter?.(type, message); + } + error(message) { + this.add('error', message); + } + warn(message) { + this.add('warning', message); + } + merge(other) { + for (const diagnostic of other.messages) { + this.add(diagnostic.type, diagnostic.message); + } + } + formatDiagnostics() { + assert_1.strict.fail('@angular/localize Diagnostics formatDiagnostics should not be called from within babel.'); + } + })(); + return diagnostics; +} +function createI18nPlugins(locale, translation, missingTranslationBehavior, diagnosticReporter, pluginCreators) { + const diagnostics = createI18nDiagnostics(diagnosticReporter); + const plugins = []; + const { makeEs2015TranslatePlugin, makeLocalePlugin } = pluginCreators; + if (translation) { + plugins.push(makeEs2015TranslatePlugin(diagnostics, translation, { + missingTranslation: missingTranslationBehavior, + })); + } + plugins.push(makeLocalePlugin(locale)); + return plugins; +} +function createNgtscLogger(reporter) { + return { + level: 1, + debug(...args) { }, + info(...args) { + reporter?.('info', args.join()); + }, + warn(...args) { + reporter?.('warning', args.join()); + }, + error(...args) { + reporter?.('error', args.join()); + }, + }; +} +function default_1(api, options) { + const presets = []; + const plugins = []; + let needRuntimeTransform = false; + if (options.angularLinker?.shouldLink) { + plugins.push(options.angularLinker.linkerPluginCreator({ + linkerJitMode: options.angularLinker.jitMode, + // This is a workaround until https://github.com/angular/angular/issues/42769 is fixed. + sourceMapping: false, + logger: createNgtscLogger(options.diagnosticReporter), + fileSystem: { + resolve: path.resolve, + exists: fs.existsSync, + dirname: path.dirname, + relative: path.relative, + readFile: fs.readFileSync, + // Node.JS types don't overlap the Compiler types. + // eslint-disable-next-line @typescript-eslint/no-explicit-any + }, + })); + } + // Applications code ES version can be controlled using TypeScript's `target` option. + // However, this doesn't effect libraries and hence we use preset-env to downlevel ES features + // based on the supported browsers in browserslist. + if (options.supportedBrowsers) { + const includePlugins = []; + // If a Safari browser affected by the class field scope bug is selected, we + // downlevel class properties by ensuring the class properties Babel plugin + // is always included- regardless of the preset-env targets. + if (options.supportedBrowsers.some((b) => safariClassFieldScopeBugBrowsers.has(b))) { + includePlugins.push('@babel/plugin-proposal-class-properties', '@babel/plugin-proposal-private-methods'); + } + presets.push([ + require('@babel/preset-env').default, + { + bugfixes: true, + modules: false, + targets: options.supportedBrowsers, + include: includePlugins, + exclude: ['transform-typeof-symbol'], + }, + ]); + needRuntimeTransform = true; + } + if (options.i18n) { + const { locale, missingTranslationBehavior, pluginCreators, translation } = options.i18n; + const i18nPlugins = createI18nPlugins(locale, translation, missingTranslationBehavior || 'ignore', options.diagnosticReporter, pluginCreators); + plugins.push(...i18nPlugins); + } + if (options.forceAsyncTransformation) { + // Always transform async/await to support Zone.js + plugins.push(require('@babel/plugin-transform-async-to-generator').default, require('@babel/plugin-proposal-async-generator-functions').default); + needRuntimeTransform = true; + } + if (options.optimize) { + if (options.optimize.pureTopLevel) { + plugins.push(require('../plugins/pure-toplevel-functions').default); + } + plugins.push(require('../plugins/elide-angular-metadata').default, [require('../plugins/adjust-typescript-enums').default, { loose: true }], [ + require('../plugins/adjust-static-class-members').default, + { wrapDecorators: options.optimize.wrapDecorators }, + ]); + } + if (options.instrumentCode) { + plugins.push([ + require('babel-plugin-istanbul').default, + { + inputSourceMap: options.instrumentCode.inputSourceMap ?? false, + cwd: options.instrumentCode.includedBasePath, + }, + ]); + } + if (needRuntimeTransform) { + // Babel equivalent to TypeScript's `importHelpers` option + plugins.push([ + require('@babel/plugin-transform-runtime').default, + { + useESModules: true, + version: require('@babel/runtime/package.json').version, + absoluteRuntime: path.dirname(require.resolve('@babel/runtime/package.json')), + }, + ]); + } + return { presets, plugins }; +} +exports.default = default_1; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"application.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/babel/presets/application.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 type { ɵParsedTranslation } from '@angular/localize';\nimport type {\n  DiagnosticHandlingStrategy,\n  Diagnostics,\n  makeEs2015TranslatePlugin,\n  makeLocalePlugin,\n} from '@angular/localize/tools';\nimport { strict as assert } from 'assert';\nimport browserslist from 'browserslist';\nimport * as fs from 'fs';\nimport * as path from 'path';\n\n/**\n * List of browsers which are affected by a WebKit bug where class field\n * initializers might have incorrect variable scopes.\n *\n * See: https://github.com/angular/angular-cli/issues/24355#issuecomment-1333477033\n * See: https://github.com/WebKit/WebKit/commit/e8788a34b3d5f5b4edd7ff6450b80936bff396f2\n */\nconst safariClassFieldScopeBugBrowsers = new Set(\n  browserslist([\n    // Safari <15 is technically not supported via https://angular.io/guide/browser-support,\n    // but we apply the workaround if forcibly selected.\n    'Safari <=15',\n    'iOS <=15',\n  ]),\n);\n\nexport type DiagnosticReporter = (type: 'error' | 'warning' | 'info', message: string) => void;\n\n/**\n * An interface representing the factory functions for the `@angular/localize` translation Babel plugins.\n * This must be provided for the ESM imports since dynamic imports are required to be asynchronous and\n * Babel presets currently can only be synchronous.\n *\n */\nexport interface I18nPluginCreators {\n  makeEs2015TranslatePlugin: typeof makeEs2015TranslatePlugin;\n  makeLocalePlugin: typeof makeLocalePlugin;\n}\n\nexport interface ApplicationPresetOptions {\n  i18n?: {\n    locale: string;\n    missingTranslationBehavior?: 'error' | 'warning' | 'ignore';\n    translation?: Record<string, ɵParsedTranslation>;\n    translationFiles?: string[];\n    pluginCreators: I18nPluginCreators;\n  };\n\n  angularLinker?: {\n    shouldLink: boolean;\n    jitMode: boolean;\n    linkerPluginCreator: typeof import('@angular/compiler-cli/linker/babel').createEs2015LinkerPlugin;\n  };\n\n  forceAsyncTransformation?: boolean;\n  instrumentCode?: {\n    includedBasePath: string;\n    inputSourceMap: unknown;\n  };\n  optimize?: {\n    pureTopLevel: boolean;\n    wrapDecorators: boolean;\n  };\n\n  supportedBrowsers?: string[];\n  diagnosticReporter?: DiagnosticReporter;\n}\n\n// Extract Logger type from the linker function to avoid deep importing to access the type\ntype NgtscLogger = Parameters<\n  typeof import('@angular/compiler-cli/linker/babel').createEs2015LinkerPlugin\n>[0]['logger'];\n\nfunction createI18nDiagnostics(reporter: DiagnosticReporter | undefined): Diagnostics {\n  const diagnostics: Diagnostics = new (class {\n    readonly messages: Diagnostics['messages'] = [];\n    hasErrors = false;\n\n    add(type: DiagnosticHandlingStrategy, message: string): void {\n      if (type === 'ignore') {\n        return;\n      }\n\n      this.messages.push({ type, message });\n      this.hasErrors ||= type === 'error';\n      reporter?.(type, message);\n    }\n\n    error(message: string): void {\n      this.add('error', message);\n    }\n\n    warn(message: string): void {\n      this.add('warning', message);\n    }\n\n    merge(other: Diagnostics): void {\n      for (const diagnostic of other.messages) {\n        this.add(diagnostic.type, diagnostic.message);\n      }\n    }\n\n    formatDiagnostics(): never {\n      assert.fail(\n        '@angular/localize Diagnostics formatDiagnostics should not be called from within babel.',\n      );\n    }\n  })();\n\n  return diagnostics;\n}\n\nfunction createI18nPlugins(\n  locale: string,\n  translation: Record<string, ɵParsedTranslation> | undefined,\n  missingTranslationBehavior: 'error' | 'warning' | 'ignore',\n  diagnosticReporter: DiagnosticReporter | undefined,\n  pluginCreators: I18nPluginCreators,\n) {\n  const diagnostics = createI18nDiagnostics(diagnosticReporter);\n  const plugins = [];\n\n  const { makeEs2015TranslatePlugin, makeLocalePlugin } = pluginCreators;\n\n  if (translation) {\n    plugins.push(\n      makeEs2015TranslatePlugin(diagnostics, translation, {\n        missingTranslation: missingTranslationBehavior,\n      }),\n    );\n  }\n\n  plugins.push(makeLocalePlugin(locale));\n\n  return plugins;\n}\n\nfunction createNgtscLogger(reporter: DiagnosticReporter | undefined): NgtscLogger {\n  return {\n    level: 1, // Info level\n    debug(...args: string[]) {},\n    info(...args: string[]) {\n      reporter?.('info', args.join());\n    },\n    warn(...args: string[]) {\n      reporter?.('warning', args.join());\n    },\n    error(...args: string[]) {\n      reporter?.('error', args.join());\n    },\n  };\n}\n\nexport default function (api: unknown, options: ApplicationPresetOptions) {\n  const presets = [];\n  const plugins = [];\n  let needRuntimeTransform = false;\n\n  if (options.angularLinker?.shouldLink) {\n    plugins.push(\n      options.angularLinker.linkerPluginCreator({\n        linkerJitMode: options.angularLinker.jitMode,\n        // This is a workaround until https://github.com/angular/angular/issues/42769 is fixed.\n        sourceMapping: false,\n        logger: createNgtscLogger(options.diagnosticReporter),\n        fileSystem: {\n          resolve: path.resolve,\n          exists: fs.existsSync,\n          dirname: path.dirname,\n          relative: path.relative,\n          readFile: fs.readFileSync,\n          // Node.JS types don't overlap the Compiler types.\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        } as any,\n      }),\n    );\n  }\n\n  // Applications code ES version can be controlled using TypeScript's `target` option.\n  // However, this doesn't effect libraries and hence we use preset-env to downlevel ES features\n  // based on the supported browsers in browserslist.\n  if (options.supportedBrowsers) {\n    const includePlugins: string[] = [];\n\n    // If a Safari browser affected by the class field scope bug is selected, we\n    // downlevel class properties by ensuring the class properties Babel plugin\n    // is always included- regardless of the preset-env targets.\n    if (options.supportedBrowsers.some((b) => safariClassFieldScopeBugBrowsers.has(b))) {\n      includePlugins.push(\n        '@babel/plugin-proposal-class-properties',\n        '@babel/plugin-proposal-private-methods',\n      );\n    }\n\n    presets.push([\n      require('@babel/preset-env').default,\n      {\n        bugfixes: true,\n        modules: false,\n        targets: options.supportedBrowsers,\n        include: includePlugins,\n        exclude: ['transform-typeof-symbol'],\n      },\n    ]);\n    needRuntimeTransform = true;\n  }\n\n  if (options.i18n) {\n    const { locale, missingTranslationBehavior, pluginCreators, translation } = options.i18n;\n    const i18nPlugins = createI18nPlugins(\n      locale,\n      translation,\n      missingTranslationBehavior || 'ignore',\n      options.diagnosticReporter,\n      pluginCreators,\n    );\n\n    plugins.push(...i18nPlugins);\n  }\n\n  if (options.forceAsyncTransformation) {\n    // Always transform async/await to support Zone.js\n    plugins.push(\n      require('@babel/plugin-transform-async-to-generator').default,\n      require('@babel/plugin-proposal-async-generator-functions').default,\n    );\n    needRuntimeTransform = true;\n  }\n\n  if (options.optimize) {\n    if (options.optimize.pureTopLevel) {\n      plugins.push(require('../plugins/pure-toplevel-functions').default);\n    }\n\n    plugins.push(\n      require('../plugins/elide-angular-metadata').default,\n      [require('../plugins/adjust-typescript-enums').default, { loose: true }],\n      [\n        require('../plugins/adjust-static-class-members').default,\n        { wrapDecorators: options.optimize.wrapDecorators },\n      ],\n    );\n  }\n\n  if (options.instrumentCode) {\n    plugins.push([\n      require('babel-plugin-istanbul').default,\n      {\n        inputSourceMap: options.instrumentCode.inputSourceMap ?? false,\n        cwd: options.instrumentCode.includedBasePath,\n      },\n    ]);\n  }\n\n  if (needRuntimeTransform) {\n    // Babel equivalent to TypeScript's `importHelpers` option\n    plugins.push([\n      require('@babel/plugin-transform-runtime').default,\n      {\n        useESModules: true,\n        version: require('@babel/runtime/package.json').version,\n        absoluteRuntime: path.dirname(require.resolve('@babel/runtime/package.json')),\n      },\n    ]);\n  }\n\n  return { presets, plugins };\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/babel/webpack-loader.d.ts b/artifacts/build-angular/src/babel/webpack-loader.d.ts new file mode 100644 index 00000000..5e2282a4 --- /dev/null +++ b/artifacts/build-angular/src/babel/webpack-loader.d.ts @@ -0,0 +1,19 @@ +/** + * @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 { ApplicationPresetOptions } from './presets/application'; +interface AngularCustomOptions extends Omit { + instrumentCode?: { + /** node_modules and test files are always excluded. */ + excludedPaths: Set; + includedBasePath: string; + }; +} +export type AngularBabelLoaderOptions = AngularCustomOptions & Record; +export declare function requiresLinking(path: string, source: string): Promise; +declare const _default: any; +export default _default; diff --git a/artifacts/build-angular/src/babel/webpack-loader.js b/artifacts/build-angular/src/babel/webpack-loader.js new file mode 100644 index 00000000..6c9f56c3 --- /dev/null +++ b/artifacts/build-angular/src/babel/webpack-loader.js @@ -0,0 +1,189 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.requiresLinking = void 0; +const babel_loader_1 = require("babel-loader"); +const load_esm_1 = require("../utils/load-esm"); +const package_version_1 = require("../utils/package-version"); +/** + * Cached instance of the compiler-cli linker's needsLinking function. + */ +let needsLinking; +/** + * Cached instance of the compiler-cli linker's Babel plugin factory function. + */ +let linkerPluginCreator; +/** + * Cached instance of the localize Babel plugins factory functions. + */ +let i18nPluginCreators; +async function requiresLinking(path, source) { + // @angular/core and @angular/compiler will cause false positives + // Also, TypeScript files do not require linking + if (/[\\/]@angular[\\/](?:compiler|core)|\.tsx?$/.test(path)) { + return false; + } + if (!needsLinking) { + // Load ESM `@angular/compiler-cli/linker` using the TypeScript dynamic import workaround. + // Once TypeScript provides support for keeping the dynamic import this workaround can be + // changed to a direct dynamic import. + const linkerModule = await (0, load_esm_1.loadEsmModule)('@angular/compiler-cli/linker'); + needsLinking = linkerModule.needsLinking; + } + return needsLinking(path, source); +} +exports.requiresLinking = requiresLinking; +// eslint-disable-next-line max-lines-per-function +exports.default = (0, babel_loader_1.custom)(() => { + const baseOptions = Object.freeze({ + babelrc: false, + configFile: false, + compact: false, + cacheCompression: false, + sourceType: 'unambiguous', + inputSourceMap: false, + }); + return { + async customOptions(options, { source, map }) { + const { i18n, aot, optimize, instrumentCode, supportedBrowsers, ...rawOptions } = options; + // Must process file if plugins are added + let shouldProcess = Array.isArray(rawOptions.plugins) && rawOptions.plugins.length > 0; + const customOptions = { + forceAsyncTransformation: false, + angularLinker: undefined, + i18n: undefined, + instrumentCode: undefined, + supportedBrowsers, + }; + // Analyze file for linking + if (await requiresLinking(this.resourcePath, source)) { + // Load ESM `@angular/compiler-cli/linker/babel` using the TypeScript dynamic import workaround. + // Once TypeScript provides support for keeping the dynamic import this workaround can be + // changed to a direct dynamic import. + linkerPluginCreator ?? (linkerPluginCreator = (await (0, load_esm_1.loadEsmModule)('@angular/compiler-cli/linker/babel')).createEs2015LinkerPlugin); + customOptions.angularLinker = { + shouldLink: true, + jitMode: aot !== true, + linkerPluginCreator, + }; + shouldProcess = true; + } + // Application code (TS files) will only contain native async if target is ES2017+. + // However, third-party libraries can regardless of the target option. + // APF packages with code in [f]esm2015 directories is downlevelled to ES2015 and + // will not have native async. + customOptions.forceAsyncTransformation = + !/[\\/][_f]?esm2015[\\/]/.test(this.resourcePath) && source.includes('async'); + shouldProcess || (shouldProcess = customOptions.forceAsyncTransformation || + customOptions.supportedBrowsers !== undefined || + false); + // Analyze for i18n inlining + if (i18n && + !/[\\/]@angular[\\/](?:compiler|localize)/.test(this.resourcePath) && + source.includes('$localize')) { + // Load the i18n plugin creators from the new `@angular/localize/tools` entry point. + // This may fail during the transition to ESM due to the entry point not yet existing. + // During the transition, this will always attempt to load the entry point for each file. + // This will only occur during prerelease and will be automatically corrected once the new + // entry point exists. + if (i18nPluginCreators === undefined) { + // Load ESM `@angular/localize/tools` using the TypeScript dynamic import workaround. + // Once TypeScript provides support for keeping the dynamic import this workaround can be + // changed to a direct dynamic import. + i18nPluginCreators = await (0, load_esm_1.loadEsmModule)('@angular/localize/tools'); + } + customOptions.i18n = { + ...i18n, + pluginCreators: i18nPluginCreators, + }; + // Add translation files as dependencies of the file to support rebuilds + // Except for `@angular/core` which needs locale injection but has no translations + if (customOptions.i18n.translationFiles && + !/[\\/]@angular[\\/]core/.test(this.resourcePath)) { + for (const file of customOptions.i18n.translationFiles) { + this.addDependency(file); + } + } + shouldProcess = true; + } + if (optimize) { + const AngularPackage = /[\\/]node_modules[\\/]@angular[\\/]/.test(this.resourcePath); + const sideEffectFree = !!this._module?.factoryMeta?.sideEffectFree; + customOptions.optimize = { + // Angular packages provide additional tested side effects guarantees and can use + // otherwise unsafe optimizations. (@angular/platform-server/init) however has side-effects. + pureTopLevel: AngularPackage && sideEffectFree, + // JavaScript modules that are marked as side effect free are considered to have + // no decorators that contain non-local effects. + wrapDecorators: sideEffectFree, + }; + shouldProcess = true; + } + if (instrumentCode && + !instrumentCode.excludedPaths.has(this.resourcePath) && + !/\.(e2e|spec)\.tsx?$|[\\/]node_modules[\\/]/.test(this.resourcePath) && + this.resourcePath.startsWith(instrumentCode.includedBasePath)) { + // `babel-plugin-istanbul` has it's own includes but we do the below so that we avoid running the the loader. + customOptions.instrumentCode = { + includedBasePath: instrumentCode.includedBasePath, + inputSourceMap: map, + }; + shouldProcess = true; + } + // Add provided loader options to default base options + const loaderOptions = { + ...baseOptions, + ...rawOptions, + cacheIdentifier: JSON.stringify({ + buildAngular: package_version_1.VERSION, + customOptions, + baseOptions, + rawOptions, + }), + }; + // Skip babel processing if no actions are needed + if (!shouldProcess) { + // Force the current file to be ignored + loaderOptions.ignore = [() => true]; + } + return { custom: customOptions, loader: loaderOptions }; + }, + config(configuration, { customOptions }) { + return { + ...configuration.options, + // Using `false` disables babel from attempting to locate sourcemaps or process any inline maps. + // The babel types do not include the false option even though it is valid + // eslint-disable-next-line @typescript-eslint/no-explicit-any + inputSourceMap: configuration.options.inputSourceMap ?? false, + presets: [ + ...(configuration.options.presets || []), + [ + require('./presets/application').default, + { + ...customOptions, + diagnosticReporter: (type, message) => { + switch (type) { + case 'error': + this.emitError(message); + break; + case 'info': + // Webpack does not currently have an informational diagnostic + case 'warning': + this.emitWarning(message); + break; + } + }, + }, + ], + ], + }; + }, + }; +}); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"webpack-loader.js","sourceRoot":"","sources":["../../../../../../../../packages/angular_devkit/build_angular/src/babel/webpack-loader.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 { custom } from 'babel-loader';\nimport { loadEsmModule } from '../utils/load-esm';\nimport { VERSION } from '../utils/package-version';\nimport { ApplicationPresetOptions, I18nPluginCreators } from './presets/application';\n\ninterface AngularCustomOptions extends Omit<ApplicationPresetOptions, 'instrumentCode'> {\n  instrumentCode?: {\n    /** node_modules and test files are always excluded. */\n    excludedPaths: Set<String>;\n    includedBasePath: string;\n  };\n}\n\nexport type AngularBabelLoaderOptions = AngularCustomOptions & Record<string, unknown>;\n\n/**\n * Cached instance of the compiler-cli linker's needsLinking function.\n */\nlet needsLinking: typeof import('@angular/compiler-cli/linker').needsLinking | undefined;\n\n/**\n * Cached instance of the compiler-cli linker's Babel plugin factory function.\n */\nlet linkerPluginCreator:\n  | typeof import('@angular/compiler-cli/linker/babel').createEs2015LinkerPlugin\n  | undefined;\n\n/**\n * Cached instance of the localize Babel plugins factory functions.\n */\nlet i18nPluginCreators: I18nPluginCreators | undefined;\n\nexport async function requiresLinking(path: string, source: string): Promise<boolean> {\n  // @angular/core and @angular/compiler will cause false positives\n  // Also, TypeScript files do not require linking\n  if (/[\\\\/]@angular[\\\\/](?:compiler|core)|\\.tsx?$/.test(path)) {\n    return false;\n  }\n\n  if (!needsLinking) {\n    // Load ESM `@angular/compiler-cli/linker` using the TypeScript dynamic import workaround.\n    // Once TypeScript provides support for keeping the dynamic import this workaround can be\n    // changed to a direct dynamic import.\n    const linkerModule = await loadEsmModule<typeof import('@angular/compiler-cli/linker')>(\n      '@angular/compiler-cli/linker',\n    );\n    needsLinking = linkerModule.needsLinking;\n  }\n\n  return needsLinking(path, source);\n}\n\n// eslint-disable-next-line max-lines-per-function\nexport default custom<ApplicationPresetOptions>(() => {\n  const baseOptions = Object.freeze({\n    babelrc: false,\n    configFile: false,\n    compact: false,\n    cacheCompression: false,\n    sourceType: 'unambiguous',\n    inputSourceMap: false,\n  });\n\n  return {\n    async customOptions(options, { source, map }) {\n      const { i18n, aot, optimize, instrumentCode, supportedBrowsers, ...rawOptions } =\n        options as AngularBabelLoaderOptions;\n\n      // Must process file if plugins are added\n      let shouldProcess = Array.isArray(rawOptions.plugins) && rawOptions.plugins.length > 0;\n\n      const customOptions: ApplicationPresetOptions = {\n        forceAsyncTransformation: false,\n        angularLinker: undefined,\n        i18n: undefined,\n        instrumentCode: undefined,\n        supportedBrowsers,\n      };\n\n      // Analyze file for linking\n      if (await requiresLinking(this.resourcePath, source)) {\n        // Load ESM `@angular/compiler-cli/linker/babel` using the TypeScript dynamic import workaround.\n        // Once TypeScript provides support for keeping the dynamic import this workaround can be\n        // changed to a direct dynamic import.\n        linkerPluginCreator ??= (\n          await loadEsmModule<typeof import('@angular/compiler-cli/linker/babel')>(\n            '@angular/compiler-cli/linker/babel',\n          )\n        ).createEs2015LinkerPlugin;\n\n        customOptions.angularLinker = {\n          shouldLink: true,\n          jitMode: aot !== true,\n          linkerPluginCreator,\n        };\n        shouldProcess = true;\n      }\n\n      // Application code (TS files) will only contain native async if target is ES2017+.\n      // However, third-party libraries can regardless of the target option.\n      // APF packages with code in [f]esm2015 directories is downlevelled to ES2015 and\n      // will not have native async.\n      customOptions.forceAsyncTransformation =\n        !/[\\\\/][_f]?esm2015[\\\\/]/.test(this.resourcePath) && source.includes('async');\n\n      shouldProcess ||=\n        customOptions.forceAsyncTransformation ||\n        customOptions.supportedBrowsers !== undefined ||\n        false;\n\n      // Analyze for i18n inlining\n      if (\n        i18n &&\n        !/[\\\\/]@angular[\\\\/](?:compiler|localize)/.test(this.resourcePath) &&\n        source.includes('$localize')\n      ) {\n        // Load the i18n plugin creators from the new `@angular/localize/tools` entry point.\n        // This may fail during the transition to ESM due to the entry point not yet existing.\n        // During the transition, this will always attempt to load the entry point for each file.\n        // This will only occur during prerelease and will be automatically corrected once the new\n        // entry point exists.\n        if (i18nPluginCreators === undefined) {\n          // Load ESM `@angular/localize/tools` using the TypeScript dynamic import workaround.\n          // Once TypeScript provides support for keeping the dynamic import this workaround can be\n          // changed to a direct dynamic import.\n          i18nPluginCreators = await loadEsmModule<I18nPluginCreators>('@angular/localize/tools');\n        }\n\n        customOptions.i18n = {\n          ...(i18n as NonNullable<ApplicationPresetOptions['i18n']>),\n          pluginCreators: i18nPluginCreators,\n        };\n\n        // Add translation files as dependencies of the file to support rebuilds\n        // Except for `@angular/core` which needs locale injection but has no translations\n        if (\n          customOptions.i18n.translationFiles &&\n          !/[\\\\/]@angular[\\\\/]core/.test(this.resourcePath)\n        ) {\n          for (const file of customOptions.i18n.translationFiles) {\n            this.addDependency(file);\n          }\n        }\n\n        shouldProcess = true;\n      }\n\n      if (optimize) {\n        const AngularPackage = /[\\\\/]node_modules[\\\\/]@angular[\\\\/]/.test(this.resourcePath);\n        const sideEffectFree = !!this._module?.factoryMeta?.sideEffectFree;\n        customOptions.optimize = {\n          // Angular packages provide additional tested side effects guarantees and can use\n          // otherwise unsafe optimizations. (@angular/platform-server/init) however has side-effects.\n          pureTopLevel: AngularPackage && sideEffectFree,\n          // JavaScript modules that are marked as side effect free are considered to have\n          // no decorators that contain non-local effects.\n          wrapDecorators: sideEffectFree,\n        };\n\n        shouldProcess = true;\n      }\n\n      if (\n        instrumentCode &&\n        !instrumentCode.excludedPaths.has(this.resourcePath) &&\n        !/\\.(e2e|spec)\\.tsx?$|[\\\\/]node_modules[\\\\/]/.test(this.resourcePath) &&\n        this.resourcePath.startsWith(instrumentCode.includedBasePath)\n      ) {\n        // `babel-plugin-istanbul` has it's own includes but we do the below so that we avoid running the the loader.\n        customOptions.instrumentCode = {\n          includedBasePath: instrumentCode.includedBasePath,\n          inputSourceMap: map,\n        };\n\n        shouldProcess = true;\n      }\n\n      // Add provided loader options to default base options\n      const loaderOptions: Record<string, unknown> = {\n        ...baseOptions,\n        ...rawOptions,\n        cacheIdentifier: JSON.stringify({\n          buildAngular: VERSION,\n          customOptions,\n          baseOptions,\n          rawOptions,\n        }),\n      };\n\n      // Skip babel processing if no actions are needed\n      if (!shouldProcess) {\n        // Force the current file to be ignored\n        loaderOptions.ignore = [() => true];\n      }\n\n      return { custom: customOptions, loader: loaderOptions };\n    },\n    config(configuration, { customOptions }) {\n      return {\n        ...configuration.options,\n        // Using `false` disables babel from attempting to locate sourcemaps or process any inline maps.\n        // The babel types do not include the false option even though it is valid\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        inputSourceMap: configuration.options.inputSourceMap ?? (false as any),\n        presets: [\n          ...(configuration.options.presets || []),\n          [\n            require('./presets/application').default,\n            {\n              ...customOptions,\n              diagnosticReporter: (type, message) => {\n                switch (type) {\n                  case 'error':\n                    this.emitError(message);\n                    break;\n                  case 'info':\n                  // Webpack does not currently have an informational diagnostic\n                  case 'warning':\n                    this.emitWarning(message);\n                    break;\n                }\n              },\n            } as ApplicationPresetOptions,\n          ],\n        ],\n      };\n    },\n  };\n});\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/app-shell/index.d.ts b/artifacts/build-angular/src/builders/app-shell/index.d.ts new file mode 100644 index 00000000..0e3aabd1 --- /dev/null +++ b/artifacts/build-angular/src/builders/app-shell/index.d.ts @@ -0,0 +1,11 @@ +/** + * @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 { JsonObject } from '@angular-devkit/core'; +import { Schema as BuildWebpackAppShellSchema } from './schema'; +declare const _default: import("../../../../architect/src/internal").Builder; +export default _default; diff --git a/artifacts/build-angular/src/builders/app-shell/index.js b/artifacts/build-angular/src/builders/app-shell/index.js new file mode 100644 index 00000000..8bb68f62 --- /dev/null +++ b/artifacts/build-angular/src/builders/app-shell/index.js @@ -0,0 +1,170 @@ +"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; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const architect_1 = require("@angular-devkit/architect"); +const fs = __importStar(require("fs")); +const path = __importStar(require("path")); +const piscina_1 = __importDefault(require("piscina")); +const utils_1 = require("../../utils"); +const error_1 = require("../../utils/error"); +const inline_critical_css_1 = require("../../utils/index-file/inline-critical-css"); +const service_worker_1 = require("../../utils/service-worker"); +const spinner_1 = require("../../utils/spinner"); +async function _renderUniversal(options, context, browserResult, serverResult, spinner) { + // Get browser target options. + const browserTarget = (0, architect_1.targetFromTargetString)(options.browserTarget); + const rawBrowserOptions = (await context.getTargetOptions(browserTarget)); + const browserBuilderName = await context.getBuilderNameForTarget(browserTarget); + const browserOptions = await context.validateOptions(rawBrowserOptions, browserBuilderName); + // Locate zone.js to load in the render worker + const root = context.workspaceRoot; + const zonePackage = require.resolve('zone.js', { paths: [root] }); + const projectName = context.target && context.target.project; + if (!projectName) { + throw new Error('The builder requires a target.'); + } + const projectMetadata = await context.getProjectMetadata(projectName); + const projectRoot = path.join(root, projectMetadata.root ?? ''); + const { styles } = (0, utils_1.normalizeOptimization)(browserOptions.optimization); + const inlineCriticalCssProcessor = styles.inlineCritical + ? new inline_critical_css_1.InlineCriticalCssProcessor({ + minify: styles.minify, + deployUrl: browserOptions.deployUrl, + }) + : undefined; + const renderWorker = new piscina_1.default({ + filename: require.resolve('./render-worker'), + maxThreads: 1, + workerData: { zonePackage }, + }); + try { + for (const { path: outputPath, baseHref } of browserResult.outputs) { + const localeDirectory = path.relative(browserResult.baseOutputPath, outputPath); + const browserIndexOutputPath = path.join(outputPath, 'index.html'); + const indexHtml = await fs.promises.readFile(browserIndexOutputPath, 'utf8'); + const serverBundlePath = await _getServerModuleBundlePath(options, context, serverResult, localeDirectory); + let html = await renderWorker.run({ + serverBundlePath, + document: indexHtml, + url: options.route, + }); + // Overwrite the client index file. + const outputIndexPath = options.outputIndexPath + ? path.join(root, options.outputIndexPath) + : browserIndexOutputPath; + if (inlineCriticalCssProcessor) { + const { content, warnings, errors } = await inlineCriticalCssProcessor.process(html, { + outputPath, + }); + html = content; + if (warnings.length || errors.length) { + spinner.stop(); + warnings.forEach((m) => context.logger.warn(m)); + errors.forEach((m) => context.logger.error(m)); + spinner.start(); + } + } + await fs.promises.writeFile(outputIndexPath, html); + if (browserOptions.serviceWorker) { + await (0, service_worker_1.augmentAppWithServiceWorker)(projectRoot, root, outputPath, baseHref ?? '/', browserOptions.ngswConfigPath); + } + } + } + finally { + await renderWorker.destroy(); + } + return browserResult; +} +async function _getServerModuleBundlePath(options, context, serverResult, browserLocaleDirectory) { + if (options.appModuleBundle) { + return path.join(context.workspaceRoot, options.appModuleBundle); + } + const { baseOutputPath = '' } = serverResult; + const outputPath = path.join(baseOutputPath, browserLocaleDirectory); + if (!fs.existsSync(outputPath)) { + throw new Error(`Could not find server output directory: ${outputPath}.`); + } + const re = /^main\.(?:[a-zA-Z0-9]{16}\.)?js$/; + const maybeMain = fs.readdirSync(outputPath).find((x) => re.test(x)); + if (!maybeMain) { + throw new Error('Could not find the main bundle.'); + } + return path.join(outputPath, maybeMain); +} +async function _appShellBuilder(options, context) { + const browserTarget = (0, architect_1.targetFromTargetString)(options.browserTarget); + const serverTarget = (0, architect_1.targetFromTargetString)(options.serverTarget); + // Never run the browser target in watch mode. + // If service worker is needed, it will be added in _renderUniversal(); + const browserOptions = (await context.getTargetOptions(browserTarget)); + const optimization = (0, utils_1.normalizeOptimization)(browserOptions.optimization); + optimization.styles.inlineCritical = false; + const browserTargetRun = await context.scheduleTarget(browserTarget, { + watch: false, + serviceWorker: false, + optimization: optimization, + }); + const serverTargetRun = await context.scheduleTarget(serverTarget, { + watch: false, + }); + let spinner; + try { + const [browserResult, serverResult] = await Promise.all([ + browserTargetRun.result, + serverTargetRun.result, + ]); + if (browserResult.success === false || browserResult.baseOutputPath === undefined) { + return browserResult; + } + else if (serverResult.success === false) { + return serverResult; + } + spinner = new spinner_1.Spinner(); + spinner.start('Generating application shell...'); + const result = await _renderUniversal(options, context, browserResult, serverResult, spinner); + spinner.succeed('Application shell generation complete.'); + return result; + } + catch (err) { + spinner?.fail('Application shell generation failed.'); + (0, error_1.assertIsError)(err); + return { success: false, error: err.message }; + } + finally { + await Promise.all([browserTargetRun.stop(), serverTargetRun.stop()]); + } +} +exports.default = (0, architect_1.createBuilder)(_appShellBuilder); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/app-shell/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 { JsonObject } from '@angular-devkit/core';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport Piscina from 'piscina';\nimport { normalizeOptimization } from '../../utils';\nimport { assertIsError } from '../../utils/error';\nimport { InlineCriticalCssProcessor } from '../../utils/index-file/inline-critical-css';\nimport { augmentAppWithServiceWorker } from '../../utils/service-worker';\nimport { Spinner } from '../../utils/spinner';\nimport { BrowserBuilderOutput } from '../browser';\nimport { Schema as BrowserBuilderSchema } from '../browser/schema';\nimport { ServerBuilderOutput } from '../server';\nimport { Schema as BuildWebpackAppShellSchema } from './schema';\n\nasync function _renderUniversal(\n  options: BuildWebpackAppShellSchema,\n  context: BuilderContext,\n  browserResult: BrowserBuilderOutput,\n  serverResult: ServerBuilderOutput,\n  spinner: Spinner,\n): Promise<BrowserBuilderOutput> {\n  // Get browser target options.\n  const browserTarget = targetFromTargetString(options.browserTarget);\n  const rawBrowserOptions = (await context.getTargetOptions(browserTarget)) as JsonObject &\n    BrowserBuilderSchema;\n  const browserBuilderName = await context.getBuilderNameForTarget(browserTarget);\n  const browserOptions = await context.validateOptions<JsonObject & BrowserBuilderSchema>(\n    rawBrowserOptions,\n    browserBuilderName,\n  );\n\n  // Locate zone.js to load in the render worker\n  const root = context.workspaceRoot;\n  const zonePackage = require.resolve('zone.js', { paths: [root] });\n\n  const projectName = context.target && context.target.project;\n  if (!projectName) {\n    throw new Error('The builder requires a target.');\n  }\n\n  const projectMetadata = await context.getProjectMetadata(projectName);\n  const projectRoot = path.join(root, (projectMetadata.root as string | undefined) ?? '');\n\n  const { styles } = normalizeOptimization(browserOptions.optimization);\n  const inlineCriticalCssProcessor = styles.inlineCritical\n    ? new InlineCriticalCssProcessor({\n        minify: styles.minify,\n        deployUrl: browserOptions.deployUrl,\n      })\n    : undefined;\n\n  const renderWorker = new Piscina({\n    filename: require.resolve('./render-worker'),\n    maxThreads: 1,\n    workerData: { zonePackage },\n  });\n\n  try {\n    for (const { path: outputPath, baseHref } of browserResult.outputs) {\n      const localeDirectory = path.relative(browserResult.baseOutputPath, outputPath);\n      const browserIndexOutputPath = path.join(outputPath, 'index.html');\n      const indexHtml = await fs.promises.readFile(browserIndexOutputPath, 'utf8');\n      const serverBundlePath = await _getServerModuleBundlePath(\n        options,\n        context,\n        serverResult,\n        localeDirectory,\n      );\n\n      let html: string = await renderWorker.run({\n        serverBundlePath,\n        document: indexHtml,\n        url: options.route,\n      });\n\n      // Overwrite the client index file.\n      const outputIndexPath = options.outputIndexPath\n        ? path.join(root, options.outputIndexPath)\n        : browserIndexOutputPath;\n\n      if (inlineCriticalCssProcessor) {\n        const { content, warnings, errors } = await inlineCriticalCssProcessor.process(html, {\n          outputPath,\n        });\n        html = content;\n\n        if (warnings.length || errors.length) {\n          spinner.stop();\n          warnings.forEach((m) => context.logger.warn(m));\n          errors.forEach((m) => context.logger.error(m));\n          spinner.start();\n        }\n      }\n\n      await fs.promises.writeFile(outputIndexPath, html);\n\n      if (browserOptions.serviceWorker) {\n        await augmentAppWithServiceWorker(\n          projectRoot,\n          root,\n          outputPath,\n          baseHref ?? '/',\n          browserOptions.ngswConfigPath,\n        );\n      }\n    }\n  } finally {\n    await renderWorker.destroy();\n  }\n\n  return browserResult;\n}\n\nasync function _getServerModuleBundlePath(\n  options: BuildWebpackAppShellSchema,\n  context: BuilderContext,\n  serverResult: ServerBuilderOutput,\n  browserLocaleDirectory: string,\n) {\n  if (options.appModuleBundle) {\n    return path.join(context.workspaceRoot, options.appModuleBundle);\n  }\n\n  const { baseOutputPath = '' } = serverResult;\n  const outputPath = path.join(baseOutputPath, browserLocaleDirectory);\n\n  if (!fs.existsSync(outputPath)) {\n    throw new Error(`Could not find server output directory: ${outputPath}.`);\n  }\n\n  const re = /^main\\.(?:[a-zA-Z0-9]{16}\\.)?js$/;\n  const maybeMain = fs.readdirSync(outputPath).find((x) => re.test(x));\n\n  if (!maybeMain) {\n    throw new Error('Could not find the main bundle.');\n  }\n\n  return path.join(outputPath, maybeMain);\n}\n\nasync function _appShellBuilder(\n  options: BuildWebpackAppShellSchema,\n  context: BuilderContext,\n): Promise<BuilderOutput> {\n  const browserTarget = targetFromTargetString(options.browserTarget);\n  const serverTarget = targetFromTargetString(options.serverTarget);\n\n  // Never run the browser target in watch mode.\n  // If service worker is needed, it will be added in _renderUniversal();\n  const browserOptions = (await context.getTargetOptions(browserTarget)) as JsonObject &\n    BrowserBuilderSchema;\n\n  const optimization = normalizeOptimization(browserOptions.optimization);\n  optimization.styles.inlineCritical = false;\n\n  const browserTargetRun = await context.scheduleTarget(browserTarget, {\n    watch: false,\n    serviceWorker: false,\n    optimization: optimization as unknown as JsonObject,\n  });\n  const serverTargetRun = await context.scheduleTarget(serverTarget, {\n    watch: false,\n  });\n\n  let spinner: Spinner | undefined;\n\n  try {\n    const [browserResult, serverResult] = await Promise.all([\n      browserTargetRun.result as Promise<BrowserBuilderOutput>,\n      serverTargetRun.result as Promise<ServerBuilderOutput>,\n    ]);\n\n    if (browserResult.success === false || browserResult.baseOutputPath === undefined) {\n      return browserResult;\n    } else if (serverResult.success === false) {\n      return serverResult;\n    }\n\n    spinner = new Spinner();\n    spinner.start('Generating application shell...');\n    const result = await _renderUniversal(options, context, browserResult, serverResult, spinner);\n    spinner.succeed('Application shell generation complete.');\n\n    return result;\n  } catch (err) {\n    spinner?.fail('Application shell generation failed.');\n    assertIsError(err);\n\n    return { success: false, error: err.message };\n  } finally {\n    await Promise.all([browserTargetRun.stop(), serverTargetRun.stop()]);\n  }\n}\n\nexport default createBuilder(_appShellBuilder);\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/app-shell/render-worker.d.ts b/artifacts/build-angular/src/builders/app-shell/render-worker.d.ts new file mode 100644 index 00000000..170f8e01 --- /dev/null +++ b/artifacts/build-angular/src/builders/app-shell/render-worker.d.ts @@ -0,0 +1,36 @@ +/** + * @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 + */ +/** + * A request to render a Server bundle generate by the universal server builder. + */ +interface RenderRequest { + /** + * The path to the server bundle that should be loaded and rendered. + */ + serverBundlePath: string; + /** + * The existing HTML document as a string that will be augmented with the rendered application. + */ + document: string; + /** + * An optional URL path that represents the Angular route that should be rendered. + */ + url: string | undefined; +} +/** + * Renders an application based on a provided server bundle path, initial document, and optional URL route. + * @param param0 A request to render a server bundle. + * @returns A promise that resolves to the render HTML document for the application. + */ +declare function render({ serverBundlePath, document, url }: RenderRequest): Promise; +/** + * The default export will be the promise returned by the initialize function. + * This is awaited by piscina prior to using the Worker. + */ +declare const _default: Promise; +export default _default; diff --git a/artifacts/build-angular/src/builders/app-shell/render-worker.js b/artifacts/build-angular/src/builders/app-shell/render-worker.js new file mode 100644 index 00000000..a7f4c2cf --- /dev/null +++ b/artifacts/build-angular/src/builders/app-shell/render-worker.js @@ -0,0 +1,91 @@ +"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; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const node_assert_1 = __importDefault(require("node:assert")); +const node_worker_threads_1 = require("node:worker_threads"); +/** + * The fully resolved path to the zone.js package that will be loaded during worker initialization. + * This is passed as workerData when setting up the worker via the `piscina` package. + */ +const { zonePackage } = node_worker_threads_1.workerData; +/** + * Renders an application based on a provided server bundle path, initial document, and optional URL route. + * @param param0 A request to render a server bundle. + * @returns A promise that resolves to the render HTML document for the application. + */ +async function render({ serverBundlePath, document, url }) { + const { ɵSERVER_CONTEXT, AppServerModule, renderModule, renderApplication, default: bootstrapAppFn, } = (await Promise.resolve(`${serverBundlePath}`).then(s => __importStar(require(s)))); + (0, node_assert_1.default)(ɵSERVER_CONTEXT, `ɵSERVER_CONTEXT was not exported from: ${serverBundlePath}.`); + const platformProviders = [ + { + provide: ɵSERVER_CONTEXT, + useValue: 'app-shell', + }, + ]; + // Render platform server module + if (bootstrapAppFn) { + (0, node_assert_1.default)(renderApplication, `renderApplication was not exported from: ${serverBundlePath}.`); + return renderApplication(bootstrapAppFn, { + document, + url, + platformProviders, + }); + } + (0, node_assert_1.default)(AppServerModule, `Neither an AppServerModule nor a bootstrapping function was exported from: ${serverBundlePath}.`); + (0, node_assert_1.default)(renderModule, `renderModule was not exported from: ${serverBundlePath}.`); + return renderModule(AppServerModule, { + document, + url, + extraProviders: platformProviders, + }); +} +/** + * Initializes the worker when it is first created by loading the Zone.js package + * into the worker instance. + * + * @returns A promise resolving to the render function of the worker. + */ +async function initialize() { + // Setup Zone.js + await Promise.resolve(`${zonePackage}`).then(s => __importStar(require(s))); + // Return the render function for use + return render; +} +/** + * The default export will be the promise returned by the initialize function. + * This is awaited by piscina prior to using the Worker. + */ +exports.default = initialize(); +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/app-shell/schema.d.ts b/artifacts/build-angular/src/builders/app-shell/schema.d.ts new file mode 100644 index 00000000..b074b99f --- /dev/null +++ b/artifacts/build-angular/src/builders/app-shell/schema.d.ts @@ -0,0 +1,36 @@ +/** + * App Shell target options for Build Facade. + */ +export interface Schema { + /** + * Script that exports the Server AppModule to render. This should be the main JavaScript + * outputted by the server target. By default we will resolve the outputPath of the + * serverTarget and find a bundle named 'main' in it (whether or not there's a hash tag). + */ + appModuleBundle?: string; + /** + * A browser builder target use for rendering the application shell in the format of + * `project:target[:configuration]`. You can also pass in more than one configuration name + * as a comma-separated list. Example: `project:target:production,staging`. + */ + browserTarget: string; + /** + * The input path for the index.html file. By default uses the output index.html of the + * browser target. + */ + inputIndexPath?: string; + /** + * The output path of the index.html file. By default will overwrite the input file. + */ + outputIndexPath?: string; + /** + * The route to render. + */ + route?: string; + /** + * A server builder target use for rendering the application shell in the format of + * `project:target[:configuration]`. You can also pass in more than one configuration name + * as a comma-separated list. Example: `project:target:production,staging`. + */ + serverTarget: string; +} diff --git a/artifacts/build-angular/src/builders/app-shell/schema.js b/artifacts/build-angular/src/builders/app-shell/schema.js new file mode 100644 index 00000000..542f0f7f --- /dev/null +++ b/artifacts/build-angular/src/builders/app-shell/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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 \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/app-shell/schema.json b/artifacts/build-angular/src/builders/app-shell/schema.json new file mode 100644 index 00000000..027cc9f8 --- /dev/null +++ b/artifacts/build-angular/src/builders/app-shell/schema.json @@ -0,0 +1,37 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema", + "title": "App Shell Target", + "description": "App Shell target options for Build Facade.", + "type": "object", + "properties": { + "browserTarget": { + "type": "string", + "description": "A browser builder target use for rendering the application shell in the format of `project:target[:configuration]`. You can also pass in more than one configuration name as a comma-separated list. Example: `project:target:production,staging`.", + "pattern": "^[^:\\s]+:[^:\\s]+(:[^\\s]+)?$" + }, + "serverTarget": { + "type": "string", + "description": "A server builder target use for rendering the application shell in the format of `project:target[:configuration]`. You can also pass in more than one configuration name as a comma-separated list. Example: `project:target:production,staging`.", + "pattern": "^[^:\\s]+:[^:\\s]+(:[^\\s]+)?$" + }, + "appModuleBundle": { + "type": "string", + "description": "Script that exports the Server AppModule to render. This should be the main JavaScript outputted by the server target. By default we will resolve the outputPath of the serverTarget and find a bundle named 'main' in it (whether or not there's a hash tag)." + }, + "route": { + "type": "string", + "description": "The route to render.", + "default": "/" + }, + "inputIndexPath": { + "type": "string", + "description": "The input path for the index.html file. By default uses the output index.html of the browser target." + }, + "outputIndexPath": { + "type": "string", + "description": "The output path of the index.html file. By default will overwrite the input file." + } + }, + "additionalProperties": false, + "required": ["browserTarget", "serverTarget"] +} diff --git a/artifacts/build-angular/src/builders/browser-esbuild/angular/angular-compilation.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/angular/angular-compilation.d.ts new file mode 100644 index 00000000..fe946d20 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/angular/angular-compilation.d.ts @@ -0,0 +1,27 @@ +/** + * @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 type ng from '@angular/compiler-cli'; +import type ts from 'typescript'; +import type { AngularHostOptions } from './angular-host'; +export interface EmitFileResult { + content?: string; + map?: string; + dependencies: readonly string[]; +} +export type FileEmitter = (file: string) => Promise; +export declare abstract class AngularCompilation { + #private; + static loadCompilerCli(): Promise; + protected loadConfiguration(tsconfig: string): Promise; + abstract initialize(tsconfig: string, hostOptions: AngularHostOptions, compilerOptionsTransformer?: (compilerOptions: ng.CompilerOptions) => ng.CompilerOptions): Promise<{ + affectedFiles: ReadonlySet; + compilerOptions: ng.CompilerOptions; + }>; + abstract collectDiagnostics(): Iterable; + abstract createFileEmitter(onAfterEmit?: (sourceFile: ts.SourceFile) => void): FileEmitter; +} diff --git a/artifacts/build-angular/src/builders/browser-esbuild/angular/angular-compilation.js b/artifacts/build-angular/src/builders/browser-esbuild/angular/angular-compilation.js new file mode 100644 index 00000000..9281a17d --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/angular/angular-compilation.js @@ -0,0 +1,51 @@ +"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 __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +}; +var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) { + if (kind === "m") throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; +}; +var _a, _AngularCompilation_angularCompilerCliModule; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.AngularCompilation = void 0; +const load_esm_1 = require("../../../utils/load-esm"); +const profiling_1 = require("../profiling"); +class AngularCompilation { + static async loadCompilerCli() { + var _b; + // This uses a wrapped dynamic import to load `@angular/compiler-cli` which is ESM. + // Once TypeScript provides support for retaining dynamic imports this workaround can be dropped. + __classPrivateFieldSet(_b = AngularCompilation, _a, __classPrivateFieldGet(_b, _a, "f", _AngularCompilation_angularCompilerCliModule) ?? await (0, load_esm_1.loadEsmModule)('@angular/compiler-cli'), "f", _AngularCompilation_angularCompilerCliModule); + return __classPrivateFieldGet(AngularCompilation, _a, "f", _AngularCompilation_angularCompilerCliModule); + } + async loadConfiguration(tsconfig) { + const { readConfiguration } = await AngularCompilation.loadCompilerCli(); + return (0, profiling_1.profileSync)('NG_READ_CONFIG', () => readConfiguration(tsconfig, { + // Angular specific configuration defaults and overrides to ensure a functioning compilation. + suppressOutputPathCheck: true, + outDir: undefined, + sourceMap: false, + declaration: false, + declarationMap: false, + allowEmptyCodegenFiles: false, + annotationsAs: 'decorators', + enableResourceInlining: false, + })); + } +} +exports.AngularCompilation = AngularCompilation; +_a = AngularCompilation; +_AngularCompilation_angularCompilerCliModule = { value: void 0 }; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/angular/angular-host.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/angular/angular-host.d.ts new file mode 100644 index 00000000..a74f2aa1 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/angular/angular-host.d.ts @@ -0,0 +1,25 @@ +/** + * @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 type ng from '@angular/compiler-cli'; +import ts from 'typescript'; +export type AngularCompilerOptions = ng.CompilerOptions; +export type AngularCompilerHost = ng.CompilerHost; +export interface AngularHostOptions { + fileReplacements?: Record; + sourceFileCache?: Map; + modifiedFiles?: Set; + transformStylesheet(data: string, containingFile: string, stylesheetFile?: string): Promise; +} +/** + * Patches in-place the `getSourceFiles` function on an instance of a TypeScript + * `Program` to ensure that all returned SourceFile instances have a `version` + * field. The `version` field is required when used with a TypeScript BuilderProgram. + * @param program The TypeScript Program instance to patch. + */ +export declare function ensureSourceFileVersions(program: ts.Program): void; +export declare function createAngularCompilerHost(compilerOptions: AngularCompilerOptions, hostOptions: AngularHostOptions): AngularCompilerHost; diff --git a/artifacts/build-angular/src/builders/browser-esbuild/angular/angular-host.js b/artifacts/build-angular/src/builders/browser-esbuild/angular/angular-host.js new file mode 100644 index 00000000..1f0a7490 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/angular/angular-host.js @@ -0,0 +1,60 @@ +"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 __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createAngularCompilerHost = exports.ensureSourceFileVersions = void 0; +const typescript_1 = __importDefault(require("typescript")); +// Temporary deep import for host augmentation support. +// TODO: Move these to a private exports location or move the implementation into this package. +const { augmentHostWithCaching, augmentHostWithReplacements, augmentProgramWithVersioning, } = require('@ngtools/webpack/src/ivy/host'); +/** + * Patches in-place the `getSourceFiles` function on an instance of a TypeScript + * `Program` to ensure that all returned SourceFile instances have a `version` + * field. The `version` field is required when used with a TypeScript BuilderProgram. + * @param program The TypeScript Program instance to patch. + */ +function ensureSourceFileVersions(program) { + augmentProgramWithVersioning(program); +} +exports.ensureSourceFileVersions = ensureSourceFileVersions; +function createAngularCompilerHost(compilerOptions, hostOptions) { + // Create TypeScript compiler host + const host = typescript_1.default.createIncrementalCompilerHost(compilerOptions); + // The AOT compiler currently requires this hook to allow for a transformResource hook. + // Once the AOT compiler allows only a transformResource hook, this can be reevaluated. + host.readResource = async function (filename) { + return this.readFile(filename) ?? ''; + }; + // Add an AOT compiler resource transform hook + host.transformResource = async function (data, context) { + // Only style resources are transformed currently + if (context.type !== 'style') { + return null; + } + const result = await hostOptions.transformStylesheet(data, context.containingFile, context.resourceFile ?? undefined); + return result ? { content: result } : null; + }; + // Allow the AOT compiler to request the set of changed templates and styles + host.getModifiedResourceFiles = function () { + return hostOptions.modifiedFiles; + }; + // Augment TypeScript Host for file replacements option + if (hostOptions.fileReplacements) { + augmentHostWithReplacements(host, hostOptions.fileReplacements); + } + // Augment TypeScript Host with source file caching if provided + if (hostOptions.sourceFileCache) { + augmentHostWithCaching(host, hostOptions.sourceFileCache); + } + return host; +} +exports.createAngularCompilerHost = createAngularCompilerHost; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/angular/aot-compilation.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/angular/aot-compilation.d.ts new file mode 100644 index 00000000..8ceda799 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/angular/aot-compilation.d.ts @@ -0,0 +1,20 @@ +/** + * @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 type ng from '@angular/compiler-cli'; +import ts from 'typescript'; +import { AngularCompilation, FileEmitter } from './angular-compilation'; +import { AngularHostOptions } from './angular-host'; +export declare class AotCompilation extends AngularCompilation { + #private; + initialize(tsconfig: string, hostOptions: AngularHostOptions, compilerOptionsTransformer?: (compilerOptions: ng.CompilerOptions) => ng.CompilerOptions): Promise<{ + affectedFiles: ReadonlySet; + compilerOptions: ng.CompilerOptions; + }>; + collectDiagnostics(): Iterable; + createFileEmitter(onAfterEmit?: (sourceFile: ts.SourceFile) => void): FileEmitter; +} diff --git a/artifacts/build-angular/src/builders/browser-esbuild/angular/aot-compilation.js b/artifacts/build-angular/src/builders/browser-esbuild/angular/aot-compilation.js new file mode 100644 index 00000000..69195bbe --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/angular/aot-compilation.js @@ -0,0 +1,168 @@ +"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 __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +}; +var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) { + if (kind === "m") throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +var _AotCompilation_state; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.AotCompilation = void 0; +const node_assert_1 = __importDefault(require("node:assert")); +const typescript_1 = __importDefault(require("typescript")); +const profiling_1 = require("../profiling"); +const angular_compilation_1 = require("./angular-compilation"); +const angular_host_1 = require("./angular-host"); +// Temporary deep import for transformer support +// TODO: Move these to a private exports location or move the implementation into this package. +const { mergeTransformers, replaceBootstrap } = require('@ngtools/webpack/src/ivy/transformation'); +class AngularCompilationState { + constructor(angularProgram, typeScriptProgram, affectedFiles, templateDiagnosticsOptimization, diagnosticCache = new WeakMap()) { + this.angularProgram = angularProgram; + this.typeScriptProgram = typeScriptProgram; + this.affectedFiles = affectedFiles; + this.templateDiagnosticsOptimization = templateDiagnosticsOptimization; + this.diagnosticCache = diagnosticCache; + } + get angularCompiler() { + return this.angularProgram.compiler; + } +} +class AotCompilation extends angular_compilation_1.AngularCompilation { + constructor() { + super(...arguments); + _AotCompilation_state.set(this, void 0); + } + async initialize(tsconfig, hostOptions, compilerOptionsTransformer) { + // Dynamically load the Angular compiler CLI package + const { NgtscProgram, OptimizeFor } = await angular_compilation_1.AngularCompilation.loadCompilerCli(); + // Load the compiler configuration and transform as needed + const { options: originalCompilerOptions, rootNames, errors: configurationDiagnostics, } = await this.loadConfiguration(tsconfig); + const compilerOptions = compilerOptionsTransformer?.(originalCompilerOptions) ?? originalCompilerOptions; + // Create Angular compiler host + const host = (0, angular_host_1.createAngularCompilerHost)(compilerOptions, hostOptions); + // Create the Angular specific program that contains the Angular compiler + const angularProgram = (0, profiling_1.profileSync)('NG_CREATE_PROGRAM', () => new NgtscProgram(rootNames, compilerOptions, host, __classPrivateFieldGet(this, _AotCompilation_state, "f")?.angularProgram)); + const angularCompiler = angularProgram.compiler; + const angularTypeScriptProgram = angularProgram.getTsProgram(); + (0, angular_host_1.ensureSourceFileVersions)(angularTypeScriptProgram); + const typeScriptProgram = typescript_1.default.createEmitAndSemanticDiagnosticsBuilderProgram(angularTypeScriptProgram, host, __classPrivateFieldGet(this, _AotCompilation_state, "f")?.typeScriptProgram, configurationDiagnostics); + await (0, profiling_1.profileAsync)('NG_ANALYZE_PROGRAM', () => angularCompiler.analyzeAsync()); + const affectedFiles = (0, profiling_1.profileSync)('NG_FIND_AFFECTED', () => findAffectedFiles(typeScriptProgram, angularCompiler)); + __classPrivateFieldSet(this, _AotCompilation_state, new AngularCompilationState(angularProgram, typeScriptProgram, affectedFiles, affectedFiles.size === 1 ? OptimizeFor.SingleFile : OptimizeFor.WholeProgram, __classPrivateFieldGet(this, _AotCompilation_state, "f")?.diagnosticCache), "f"); + return { affectedFiles, compilerOptions }; + } + *collectDiagnostics() { + (0, node_assert_1.default)(__classPrivateFieldGet(this, _AotCompilation_state, "f"), 'Angular compilation must be initialized prior to collecting diagnostics.'); + const { affectedFiles, angularCompiler, diagnosticCache, templateDiagnosticsOptimization, typeScriptProgram, } = __classPrivateFieldGet(this, _AotCompilation_state, "f"); + // Collect program level diagnostics + yield* typeScriptProgram.getConfigFileParsingDiagnostics(); + yield* angularCompiler.getOptionDiagnostics(); + yield* typeScriptProgram.getOptionsDiagnostics(); + yield* typeScriptProgram.getGlobalDiagnostics(); + // Collect source file specific diagnostics + for (const sourceFile of typeScriptProgram.getSourceFiles()) { + if (angularCompiler.ignoreForDiagnostics.has(sourceFile)) { + continue; + } + // TypeScript will use cached diagnostics for files that have not been + // changed or affected for this build when using incremental building. + yield* (0, profiling_1.profileSync)('NG_DIAGNOSTICS_SYNTACTIC', () => typeScriptProgram.getSyntacticDiagnostics(sourceFile), true); + yield* (0, profiling_1.profileSync)('NG_DIAGNOSTICS_SEMANTIC', () => typeScriptProgram.getSemanticDiagnostics(sourceFile), true); + // Declaration files cannot have template diagnostics + if (sourceFile.isDeclarationFile) { + continue; + } + // Only request Angular template diagnostics for affected files to avoid + // overhead of template diagnostics for unchanged files. + if (affectedFiles.has(sourceFile)) { + const angularDiagnostics = (0, profiling_1.profileSync)('NG_DIAGNOSTICS_TEMPLATE', () => angularCompiler.getDiagnosticsForFile(sourceFile, templateDiagnosticsOptimization), true); + diagnosticCache.set(sourceFile, angularDiagnostics); + yield* angularDiagnostics; + } + else { + const angularDiagnostics = diagnosticCache.get(sourceFile); + if (angularDiagnostics) { + yield* angularDiagnostics; + } + } + } + } + createFileEmitter(onAfterEmit) { + (0, node_assert_1.default)(__classPrivateFieldGet(this, _AotCompilation_state, "f"), 'Angular compilation must be initialized prior to emitting files.'); + const { angularCompiler, typeScriptProgram } = __classPrivateFieldGet(this, _AotCompilation_state, "f"); + const transformers = mergeTransformers(angularCompiler.prepareEmit().transformers, { + before: [replaceBootstrap(() => typeScriptProgram.getProgram().getTypeChecker())], + }); + return async (file) => { + const sourceFile = typeScriptProgram.getSourceFile(file); + if (!sourceFile) { + return undefined; + } + let content; + typeScriptProgram.emit(sourceFile, (filename, data) => { + if (/\.[cm]?js$/.test(filename)) { + content = data; + } + }, undefined /* cancellationToken */, undefined /* emitOnlyDtsFiles */, transformers); + angularCompiler.incrementalCompilation.recordSuccessfulEmit(sourceFile); + onAfterEmit?.(sourceFile); + return { content, dependencies: [] }; + }; + } +} +exports.AotCompilation = AotCompilation; +_AotCompilation_state = new WeakMap(); +function findAffectedFiles(builder, { ignoreForDiagnostics, ignoreForEmit, incrementalCompilation }) { + const affectedFiles = new Set(); + // eslint-disable-next-line no-constant-condition + while (true) { + const result = builder.getSemanticDiagnosticsOfNextAffectedFile(undefined, (sourceFile) => { + // If the affected file is a TTC shim, add the shim's original source file. + // This ensures that changes that affect TTC are typechecked even when the changes + // are otherwise unrelated from a TS perspective and do not result in Ivy codegen changes. + // For example, changing @Input property types of a directive used in another component's + // template. + // A TTC shim is a file that has been ignored for diagnostics and has a filename ending in `.ngtypecheck.ts`. + if (ignoreForDiagnostics.has(sourceFile) && sourceFile.fileName.endsWith('.ngtypecheck.ts')) { + // This file name conversion relies on internal compiler logic and should be converted + // to an official method when available. 15 is length of `.ngtypecheck.ts` + const originalFilename = sourceFile.fileName.slice(0, -15) + '.ts'; + const originalSourceFile = builder.getSourceFile(originalFilename); + if (originalSourceFile) { + affectedFiles.add(originalSourceFile); + } + return true; + } + return false; + }); + if (!result) { + break; + } + affectedFiles.add(result.affected); + } + // A file is also affected if the Angular compiler requires it to be emitted + for (const sourceFile of builder.getSourceFiles()) { + if (ignoreForEmit.has(sourceFile) || incrementalCompilation.safeToSkipEmit(sourceFile)) { + continue; + } + affectedFiles.add(sourceFile); + } + return affectedFiles; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aot-compilation.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/angular/aot-compilation.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 type ng from '@angular/compiler-cli';\nimport assert from 'node:assert';\nimport ts from 'typescript';\nimport { profileAsync, profileSync } from '../profiling';\nimport { AngularCompilation, FileEmitter } from './angular-compilation';\nimport {\n  AngularHostOptions,\n  createAngularCompilerHost,\n  ensureSourceFileVersions,\n} from './angular-host';\n\n// Temporary deep import for transformer support\n// TODO: Move these to a private exports location or move the implementation into this package.\nconst { mergeTransformers, replaceBootstrap } = require('@ngtools/webpack/src/ivy/transformation');\n\nclass AngularCompilationState {\n  constructor(\n    public readonly angularProgram: ng.NgtscProgram,\n    public readonly typeScriptProgram: ts.EmitAndSemanticDiagnosticsBuilderProgram,\n    public readonly affectedFiles: ReadonlySet<ts.SourceFile>,\n    public readonly templateDiagnosticsOptimization: ng.OptimizeFor,\n    public readonly diagnosticCache = new WeakMap<ts.SourceFile, ts.Diagnostic[]>(),\n  ) {}\n\n  get angularCompiler() {\n    return this.angularProgram.compiler;\n  }\n}\n\nexport class AotCompilation extends AngularCompilation {\n  #state?: AngularCompilationState;\n\n  async initialize(\n    tsconfig: string,\n    hostOptions: AngularHostOptions,\n    compilerOptionsTransformer?: (compilerOptions: ng.CompilerOptions) => ng.CompilerOptions,\n  ): Promise<{ affectedFiles: ReadonlySet<ts.SourceFile>; compilerOptions: ng.CompilerOptions }> {\n    // Dynamically load the Angular compiler CLI package\n    const { NgtscProgram, OptimizeFor } = await AngularCompilation.loadCompilerCli();\n\n    // Load the compiler configuration and transform as needed\n    const {\n      options: originalCompilerOptions,\n      rootNames,\n      errors: configurationDiagnostics,\n    } = await this.loadConfiguration(tsconfig);\n    const compilerOptions =\n      compilerOptionsTransformer?.(originalCompilerOptions) ?? originalCompilerOptions;\n\n    // Create Angular compiler host\n    const host = createAngularCompilerHost(compilerOptions, hostOptions);\n\n    // Create the Angular specific program that contains the Angular compiler\n    const angularProgram = profileSync(\n      'NG_CREATE_PROGRAM',\n      () => new NgtscProgram(rootNames, compilerOptions, host, this.#state?.angularProgram),\n    );\n    const angularCompiler = angularProgram.compiler;\n    const angularTypeScriptProgram = angularProgram.getTsProgram();\n    ensureSourceFileVersions(angularTypeScriptProgram);\n\n    const typeScriptProgram = ts.createEmitAndSemanticDiagnosticsBuilderProgram(\n      angularTypeScriptProgram,\n      host,\n      this.#state?.typeScriptProgram,\n      configurationDiagnostics,\n    );\n\n    await profileAsync('NG_ANALYZE_PROGRAM', () => angularCompiler.analyzeAsync());\n    const affectedFiles = profileSync('NG_FIND_AFFECTED', () =>\n      findAffectedFiles(typeScriptProgram, angularCompiler),\n    );\n\n    this.#state = new AngularCompilationState(\n      angularProgram,\n      typeScriptProgram,\n      affectedFiles,\n      affectedFiles.size === 1 ? OptimizeFor.SingleFile : OptimizeFor.WholeProgram,\n      this.#state?.diagnosticCache,\n    );\n\n    return { affectedFiles, compilerOptions };\n  }\n\n  *collectDiagnostics(): Iterable<ts.Diagnostic> {\n    assert(this.#state, 'Angular compilation must be initialized prior to collecting diagnostics.');\n    const {\n      affectedFiles,\n      angularCompiler,\n      diagnosticCache,\n      templateDiagnosticsOptimization,\n      typeScriptProgram,\n    } = this.#state;\n\n    // Collect program level diagnostics\n    yield* typeScriptProgram.getConfigFileParsingDiagnostics();\n    yield* angularCompiler.getOptionDiagnostics();\n    yield* typeScriptProgram.getOptionsDiagnostics();\n    yield* typeScriptProgram.getGlobalDiagnostics();\n\n    // Collect source file specific diagnostics\n    for (const sourceFile of typeScriptProgram.getSourceFiles()) {\n      if (angularCompiler.ignoreForDiagnostics.has(sourceFile)) {\n        continue;\n      }\n\n      // TypeScript will use cached diagnostics for files that have not been\n      // changed or affected for this build when using incremental building.\n      yield* profileSync(\n        'NG_DIAGNOSTICS_SYNTACTIC',\n        () => typeScriptProgram.getSyntacticDiagnostics(sourceFile),\n        true,\n      );\n      yield* profileSync(\n        'NG_DIAGNOSTICS_SEMANTIC',\n        () => typeScriptProgram.getSemanticDiagnostics(sourceFile),\n        true,\n      );\n\n      // Declaration files cannot have template diagnostics\n      if (sourceFile.isDeclarationFile) {\n        continue;\n      }\n\n      // Only request Angular template diagnostics for affected files to avoid\n      // overhead of template diagnostics for unchanged files.\n      if (affectedFiles.has(sourceFile)) {\n        const angularDiagnostics = profileSync(\n          'NG_DIAGNOSTICS_TEMPLATE',\n          () => angularCompiler.getDiagnosticsForFile(sourceFile, templateDiagnosticsOptimization),\n          true,\n        );\n        diagnosticCache.set(sourceFile, angularDiagnostics);\n        yield* angularDiagnostics;\n      } else {\n        const angularDiagnostics = diagnosticCache.get(sourceFile);\n        if (angularDiagnostics) {\n          yield* angularDiagnostics;\n        }\n      }\n    }\n  }\n\n  createFileEmitter(onAfterEmit?: (sourceFile: ts.SourceFile) => void): FileEmitter {\n    assert(this.#state, 'Angular compilation must be initialized prior to emitting files.');\n    const { angularCompiler, typeScriptProgram } = this.#state;\n\n    const transformers = mergeTransformers(angularCompiler.prepareEmit().transformers, {\n      before: [replaceBootstrap(() => typeScriptProgram.getProgram().getTypeChecker())],\n    });\n\n    return async (file: string) => {\n      const sourceFile = typeScriptProgram.getSourceFile(file);\n      if (!sourceFile) {\n        return undefined;\n      }\n\n      let content: string | undefined;\n      typeScriptProgram.emit(\n        sourceFile,\n        (filename, data) => {\n          if (/\\.[cm]?js$/.test(filename)) {\n            content = data;\n          }\n        },\n        undefined /* cancellationToken */,\n        undefined /* emitOnlyDtsFiles */,\n        transformers,\n      );\n\n      angularCompiler.incrementalCompilation.recordSuccessfulEmit(sourceFile);\n      onAfterEmit?.(sourceFile);\n\n      return { content, dependencies: [] };\n    };\n  }\n}\n\nfunction findAffectedFiles(\n  builder: ts.EmitAndSemanticDiagnosticsBuilderProgram,\n  { ignoreForDiagnostics, ignoreForEmit, incrementalCompilation }: ng.NgtscProgram['compiler'],\n): Set<ts.SourceFile> {\n  const affectedFiles = new Set<ts.SourceFile>();\n\n  // eslint-disable-next-line no-constant-condition\n  while (true) {\n    const result = builder.getSemanticDiagnosticsOfNextAffectedFile(undefined, (sourceFile) => {\n      // If the affected file is a TTC shim, add the shim's original source file.\n      // This ensures that changes that affect TTC are typechecked even when the changes\n      // are otherwise unrelated from a TS perspective and do not result in Ivy codegen changes.\n      // For example, changing @Input property types of a directive used in another component's\n      // template.\n      // A TTC shim is a file that has been ignored for diagnostics and has a filename ending in `.ngtypecheck.ts`.\n      if (ignoreForDiagnostics.has(sourceFile) && sourceFile.fileName.endsWith('.ngtypecheck.ts')) {\n        // This file name conversion relies on internal compiler logic and should be converted\n        // to an official method when available. 15 is length of `.ngtypecheck.ts`\n        const originalFilename = sourceFile.fileName.slice(0, -15) + '.ts';\n        const originalSourceFile = builder.getSourceFile(originalFilename);\n        if (originalSourceFile) {\n          affectedFiles.add(originalSourceFile);\n        }\n\n        return true;\n      }\n\n      return false;\n    });\n\n    if (!result) {\n      break;\n    }\n\n    affectedFiles.add(result.affected as ts.SourceFile);\n  }\n\n  // A file is also affected if the Angular compiler requires it to be emitted\n  for (const sourceFile of builder.getSourceFiles()) {\n    if (ignoreForEmit.has(sourceFile) || incrementalCompilation.safeToSkipEmit(sourceFile)) {\n      continue;\n    }\n\n    affectedFiles.add(sourceFile);\n  }\n\n  return affectedFiles;\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/angular/compiler-plugin.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/angular/compiler-plugin.d.ts new file mode 100644 index 00000000..eae17a6e --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/angular/compiler-plugin.d.ts @@ -0,0 +1,31 @@ +/** + * @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 type { Plugin } from 'esbuild'; +import ts from 'typescript'; +import { LoadResultCache, MemoryLoadResultCache } from '../load-result-cache'; +import { BundleStylesheetOptions } from '../stylesheets/bundle-options'; +export declare class SourceFileCache extends Map { + readonly modifiedFiles: Set; + readonly babelFileCache: Map; + readonly typeScriptFileCache: Map; + readonly loadResultCache: MemoryLoadResultCache; + invalidate(files: Iterable): void; +} +export interface CompilerPluginOptions { + sourcemap: boolean; + tsconfig: string; + jit?: boolean; + advancedOptimizations?: boolean; + thirdPartySourcemaps?: boolean; + fileReplacements?: Record; + sourceFileCache?: SourceFileCache; + loadResultCache?: LoadResultCache; +} +export declare function createCompilerPlugin(pluginOptions: CompilerPluginOptions, styleOptions: BundleStylesheetOptions & { + inlineStyleLanguage: string; +}): Plugin; diff --git a/artifacts/build-angular/src/builders/browser-esbuild/angular/compiler-plugin.js b/artifacts/build-angular/src/builders/browser-esbuild/angular/compiler-plugin.js new file mode 100644 index 00000000..ea9b0459 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/angular/compiler-plugin.js @@ -0,0 +1,300 @@ +"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; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createCompilerPlugin = exports.SourceFileCache = void 0; +const assert = __importStar(require("node:assert")); +const promises_1 = require("node:fs/promises"); +const node_os_1 = require("node:os"); +const path = __importStar(require("node:path")); +const node_url_1 = require("node:url"); +const typescript_1 = __importDefault(require("typescript")); +const environment_options_1 = require("../../../utils/environment-options"); +const javascript_transformer_1 = require("../javascript-transformer"); +const load_result_cache_1 = require("../load-result-cache"); +const profiling_1 = require("../profiling"); +const bundle_options_1 = require("../stylesheets/bundle-options"); +const angular_compilation_1 = require("./angular-compilation"); +const aot_compilation_1 = require("./aot-compilation"); +const diagnostics_1 = require("./diagnostics"); +const jit_compilation_1 = require("./jit-compilation"); +const jit_plugin_callbacks_1 = require("./jit-plugin-callbacks"); +const USING_WINDOWS = (0, node_os_1.platform)() === 'win32'; +const WINDOWS_SEP_REGEXP = new RegExp(`\\${path.win32.sep}`, 'g'); +class SourceFileCache extends Map { + constructor() { + super(...arguments); + this.modifiedFiles = new Set(); + this.babelFileCache = new Map(); + this.typeScriptFileCache = new Map(); + this.loadResultCache = new load_result_cache_1.MemoryLoadResultCache(); + } + invalidate(files) { + this.modifiedFiles.clear(); + for (let file of files) { + this.babelFileCache.delete(file); + this.typeScriptFileCache.delete((0, node_url_1.pathToFileURL)(file).href); + this.loadResultCache.invalidate(file); + // Normalize separators to allow matching TypeScript Host paths + if (USING_WINDOWS) { + file = file.replace(WINDOWS_SEP_REGEXP, path.posix.sep); + } + this.delete(file); + this.modifiedFiles.add(file); + } + } +} +exports.SourceFileCache = SourceFileCache; +// eslint-disable-next-line max-lines-per-function +function createCompilerPlugin(pluginOptions, styleOptions) { + return { + name: 'angular-compiler', + // eslint-disable-next-line max-lines-per-function + async setup(build) { + var _a; + let setupWarnings = []; + const preserveSymlinks = build.initialOptions.preserveSymlinks; + let tsconfigPath = pluginOptions.tsconfig; + if (!preserveSymlinks) { + // Use the real path of the tsconfig if not preserving symlinks. + // This ensures the TS source file paths are based on the real path of the configuration. + try { + tsconfigPath = await (0, promises_1.realpath)(tsconfigPath); + } + catch { } + } + // Initialize a worker pool for JavaScript transformations + const javascriptTransformer = new javascript_transformer_1.JavaScriptTransformer(pluginOptions, environment_options_1.maxWorkers); + // Setup defines based on the values provided by the Angular compiler-cli + const { GLOBAL_DEFS_FOR_TERSER_WITH_AOT } = await angular_compilation_1.AngularCompilation.loadCompilerCli(); + (_a = build.initialOptions).define ?? (_a.define = {}); + for (const [key, value] of Object.entries(GLOBAL_DEFS_FOR_TERSER_WITH_AOT)) { + if (key in build.initialOptions.define) { + // Skip keys that have been manually provided + continue; + } + if (key === 'ngDevMode') { + // ngDevMode is already set based on the builder's script optimization option + continue; + } + // esbuild requires values to be a string (actual strings need to be quoted). + // In this case, all provided values are booleans. + build.initialOptions.define[key] = value.toString(); + } + // The file emitter created during `onStart` that will be used during the build in `onLoad` callbacks for TS files + let fileEmitter; + // The stylesheet resources from component stylesheets that will be added to the build results output files + let stylesheetResourceFiles = []; + let stylesheetMetafiles; + // Create new reusable compilation for the appropriate mode based on the `jit` plugin option + const compilation = pluginOptions.jit + ? new jit_compilation_1.JitCompilation() + : new aot_compilation_1.AotCompilation(); + // Determines if TypeScript should process JavaScript files based on tsconfig `allowJs` option + let shouldTsIgnoreJs = true; + build.onStart(async () => { + const result = { + warnings: setupWarnings, + }; + // Reset debug performance tracking + (0, profiling_1.resetCumulativeDurations)(); + // Reset stylesheet resource output files + stylesheetResourceFiles = []; + stylesheetMetafiles = []; + // Create Angular compiler host options + const hostOptions = { + fileReplacements: pluginOptions.fileReplacements, + modifiedFiles: pluginOptions.sourceFileCache?.modifiedFiles, + sourceFileCache: pluginOptions.sourceFileCache, + async transformStylesheet(data, containingFile, stylesheetFile) { + // Stylesheet file only exists for external stylesheets + const filename = stylesheetFile ?? containingFile; + const stylesheetResult = await (0, bundle_options_1.bundleComponentStylesheet)(styleOptions.inlineStyleLanguage, data, filename, !stylesheetFile, styleOptions, pluginOptions.loadResultCache); + const { contents, resourceFiles, errors, warnings } = stylesheetResult; + if (errors) { + (result.errors ?? (result.errors = [])).push(...errors); + } + (result.warnings ?? (result.warnings = [])).push(...warnings); + stylesheetResourceFiles.push(...resourceFiles); + if (stylesheetResult.metafile) { + stylesheetMetafiles.push(stylesheetResult.metafile); + } + return contents; + }, + }; + // Initialize the Angular compilation for the current build. + // In watch mode, previous build state will be reused. + const { affectedFiles, compilerOptions: { allowJs }, } = await compilation.initialize(tsconfigPath, hostOptions, (compilerOptions) => { + if (compilerOptions.target === undefined || + compilerOptions.target < typescript_1.default.ScriptTarget.ES2022) { + // If 'useDefineForClassFields' is already defined in the users project leave the value as is. + // Otherwise fallback to false due to https://github.com/microsoft/TypeScript/issues/45995 + // which breaks the deprecated `@Effects` NGRX decorator and potentially other existing code as well. + compilerOptions.target = typescript_1.default.ScriptTarget.ES2022; + compilerOptions.useDefineForClassFields ?? (compilerOptions.useDefineForClassFields = false); + // Only add the warning on the initial build + setupWarnings?.push({ + text: 'TypeScript compiler options "target" and "useDefineForClassFields" are set to "ES2022" and ' + + '"false" respectively by the Angular CLI.', + location: { file: pluginOptions.tsconfig }, + notes: [ + { + text: 'To control ECMA version and features use the Browerslist configuration. ' + + 'For more information, see https://angular.io/guide/build#configuring-browser-compatibility', + }, + ], + }); + } + return { + ...compilerOptions, + noEmitOnError: false, + inlineSources: pluginOptions.sourcemap, + inlineSourceMap: pluginOptions.sourcemap, + mapRoot: undefined, + sourceRoot: undefined, + preserveSymlinks, + }; + }); + shouldTsIgnoreJs = !allowJs; + // Clear affected files from the cache (if present) + if (pluginOptions.sourceFileCache) { + for (const affected of affectedFiles) { + pluginOptions.sourceFileCache.typeScriptFileCache.delete((0, node_url_1.pathToFileURL)(affected.fileName).href); + } + } + (0, profiling_1.profileSync)('NG_DIAGNOSTICS_TOTAL', () => { + for (const diagnostic of compilation.collectDiagnostics()) { + const message = (0, diagnostics_1.convertTypeScriptDiagnostic)(diagnostic); + if (diagnostic.category === typescript_1.default.DiagnosticCategory.Error) { + (result.errors ?? (result.errors = [])).push(message); + } + else { + (result.warnings ?? (result.warnings = [])).push(message); + } + } + }); + fileEmitter = compilation.createFileEmitter(); + // Reset the setup warnings so that they are only shown during the first build. + setupWarnings = undefined; + return result; + }); + build.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, (args) => (0, profiling_1.profileAsync)('NG_EMIT_TS*', async () => { + assert.ok(fileEmitter, 'Invalid plugin execution order'); + const request = pluginOptions.fileReplacements?.[args.path] ?? args.path; + // Skip TS load attempt if JS TypeScript compilation not enabled and file is JS + if (shouldTsIgnoreJs && /\.[cm]?js$/.test(request)) { + return undefined; + } + // The filename is currently used as a cache key. Since the cache is memory only, + // the options cannot change and do not need to be represented in the key. If the + // cache is later stored to disk, then the options that affect transform output + // would need to be added to the key as well as a check for any change of content. + let contents = pluginOptions.sourceFileCache?.typeScriptFileCache.get((0, node_url_1.pathToFileURL)(request).href); + if (contents === undefined) { + const typescriptResult = await fileEmitter(request); + if (!typescriptResult?.content) { + // No TS result indicates the file is not part of the TypeScript program. + // If allowJs is enabled and the file is JS then defer to the next load hook. + if (!shouldTsIgnoreJs && /\.[cm]?js$/.test(request)) { + return undefined; + } + // Otherwise return an error + return { + errors: [ + createMissingFileError(request, args.path, build.initialOptions.absWorkingDir ?? ''), + ], + }; + } + contents = await javascriptTransformer.transformData(request, typescriptResult.content, true /* skipLinker */); + pluginOptions.sourceFileCache?.typeScriptFileCache.set((0, node_url_1.pathToFileURL)(request).href, contents); + } + return { + contents, + loader: 'js', + }; + }, true)); + build.onLoad({ filter: /\.[cm]?js$/ }, (args) => (0, profiling_1.profileAsync)('NG_EMIT_JS*', async () => { + // The filename is currently used as a cache key. Since the cache is memory only, + // the options cannot change and do not need to be represented in the key. If the + // cache is later stored to disk, then the options that affect transform output + // would need to be added to the key as well as a check for any change of content. + let contents = pluginOptions.sourceFileCache?.babelFileCache.get(args.path); + if (contents === undefined) { + contents = await javascriptTransformer.transformFile(args.path, pluginOptions.jit); + pluginOptions.sourceFileCache?.babelFileCache.set(args.path, contents); + } + return { + contents, + loader: 'js', + }; + }, true)); + // Setup bundling of component templates and stylesheets when in JIT mode + if (pluginOptions.jit) { + (0, jit_plugin_callbacks_1.setupJitPluginCallbacks)(build, styleOptions, stylesheetResourceFiles, pluginOptions.loadResultCache); + } + build.onEnd((result) => { + // Add any component stylesheet resource files to the output files + if (stylesheetResourceFiles.length) { + result.outputFiles?.push(...stylesheetResourceFiles); + } + // Combine component stylesheet metafiles with main metafile + if (result.metafile && stylesheetMetafiles.length) { + for (const metafile of stylesheetMetafiles) { + result.metafile.inputs = { ...result.metafile.inputs, ...metafile.inputs }; + result.metafile.outputs = { ...result.metafile.outputs, ...metafile.outputs }; + } + } + (0, profiling_1.logCumulativeDurations)(); + }); + }, + }; +} +exports.createCompilerPlugin = createCompilerPlugin; +function createMissingFileError(request, original, root) { + const error = { + text: `File '${path.relative(root, request)}' is missing from the TypeScript compilation.`, + notes: [ + { + text: `Ensure the file is part of the TypeScript program via the 'files' or 'include' property.`, + }, + ], + }; + if (request !== original) { + error.notes.push({ + text: `File is requested from a file replacement of '${path.relative(root, original)}'.`, + }); + } + return error; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compiler-plugin.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/angular/compiler-plugin.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 type {\n  Metafile,\n  OnStartResult,\n  OutputFile,\n  PartialMessage,\n  Plugin,\n  PluginBuild,\n} from 'esbuild';\nimport * as assert from 'node:assert';\nimport { realpath } from 'node:fs/promises';\nimport { platform } from 'node:os';\nimport * as path from 'node:path';\nimport { pathToFileURL } from 'node:url';\nimport ts from 'typescript';\nimport { maxWorkers } from '../../../utils/environment-options';\nimport { JavaScriptTransformer } from '../javascript-transformer';\nimport { LoadResultCache, MemoryLoadResultCache } from '../load-result-cache';\nimport {\n  logCumulativeDurations,\n  profileAsync,\n  profileSync,\n  resetCumulativeDurations,\n} from '../profiling';\nimport { BundleStylesheetOptions, bundleComponentStylesheet } from '../stylesheets/bundle-options';\nimport { AngularCompilation, FileEmitter } from './angular-compilation';\nimport { AngularHostOptions } from './angular-host';\nimport { AotCompilation } from './aot-compilation';\nimport { convertTypeScriptDiagnostic } from './diagnostics';\nimport { JitCompilation } from './jit-compilation';\nimport { setupJitPluginCallbacks } from './jit-plugin-callbacks';\n\nconst USING_WINDOWS = platform() === 'win32';\nconst WINDOWS_SEP_REGEXP = new RegExp(`\\\\${path.win32.sep}`, 'g');\n\nexport class SourceFileCache extends Map<string, ts.SourceFile> {\n  readonly modifiedFiles = new Set<string>();\n  readonly babelFileCache = new Map<string, Uint8Array>();\n  readonly typeScriptFileCache = new Map<string, Uint8Array>();\n  readonly loadResultCache = new MemoryLoadResultCache();\n\n  invalidate(files: Iterable<string>): void {\n    this.modifiedFiles.clear();\n    for (let file of files) {\n      this.babelFileCache.delete(file);\n      this.typeScriptFileCache.delete(pathToFileURL(file).href);\n      this.loadResultCache.invalidate(file);\n\n      // Normalize separators to allow matching TypeScript Host paths\n      if (USING_WINDOWS) {\n        file = file.replace(WINDOWS_SEP_REGEXP, path.posix.sep);\n      }\n\n      this.delete(file);\n      this.modifiedFiles.add(file);\n    }\n  }\n}\n\nexport interface CompilerPluginOptions {\n  sourcemap: boolean;\n  tsconfig: string;\n  jit?: boolean;\n  advancedOptimizations?: boolean;\n  thirdPartySourcemaps?: boolean;\n  fileReplacements?: Record<string, string>;\n  sourceFileCache?: SourceFileCache;\n  loadResultCache?: LoadResultCache;\n}\n\n// eslint-disable-next-line max-lines-per-function\nexport function createCompilerPlugin(\n  pluginOptions: CompilerPluginOptions,\n  styleOptions: BundleStylesheetOptions & { inlineStyleLanguage: string },\n): Plugin {\n  return {\n    name: 'angular-compiler',\n    // eslint-disable-next-line max-lines-per-function\n    async setup(build: PluginBuild): Promise<void> {\n      let setupWarnings: PartialMessage[] | undefined = [];\n\n      const preserveSymlinks = build.initialOptions.preserveSymlinks;\n      let tsconfigPath = pluginOptions.tsconfig;\n      if (!preserveSymlinks) {\n        // Use the real path of the tsconfig if not preserving symlinks.\n        // This ensures the TS source file paths are based on the real path of the configuration.\n        try {\n          tsconfigPath = await realpath(tsconfigPath);\n        } catch {}\n      }\n\n      // Initialize a worker pool for JavaScript transformations\n      const javascriptTransformer = new JavaScriptTransformer(pluginOptions, maxWorkers);\n\n      // Setup defines based on the values provided by the Angular compiler-cli\n      const { GLOBAL_DEFS_FOR_TERSER_WITH_AOT } = await AngularCompilation.loadCompilerCli();\n      build.initialOptions.define ??= {};\n      for (const [key, value] of Object.entries(GLOBAL_DEFS_FOR_TERSER_WITH_AOT)) {\n        if (key in build.initialOptions.define) {\n          // Skip keys that have been manually provided\n          continue;\n        }\n        if (key === 'ngDevMode') {\n          // ngDevMode is already set based on the builder's script optimization option\n          continue;\n        }\n        // esbuild requires values to be a string (actual strings need to be quoted).\n        // In this case, all provided values are booleans.\n        build.initialOptions.define[key] = value.toString();\n      }\n\n      // The file emitter created during `onStart` that will be used during the build in `onLoad` callbacks for TS files\n      let fileEmitter: FileEmitter | undefined;\n\n      // The stylesheet resources from component stylesheets that will be added to the build results output files\n      let stylesheetResourceFiles: OutputFile[] = [];\n      let stylesheetMetafiles: Metafile[];\n\n      // Create new reusable compilation for the appropriate mode based on the `jit` plugin option\n      const compilation: AngularCompilation = pluginOptions.jit\n        ? new JitCompilation()\n        : new AotCompilation();\n\n      // Determines if TypeScript should process JavaScript files based on tsconfig `allowJs` option\n      let shouldTsIgnoreJs = true;\n\n      build.onStart(async () => {\n        const result: OnStartResult = {\n          warnings: setupWarnings,\n        };\n\n        // Reset debug performance tracking\n        resetCumulativeDurations();\n\n        // Reset stylesheet resource output files\n        stylesheetResourceFiles = [];\n        stylesheetMetafiles = [];\n\n        // Create Angular compiler host options\n        const hostOptions: AngularHostOptions = {\n          fileReplacements: pluginOptions.fileReplacements,\n          modifiedFiles: pluginOptions.sourceFileCache?.modifiedFiles,\n          sourceFileCache: pluginOptions.sourceFileCache,\n          async transformStylesheet(data, containingFile, stylesheetFile) {\n            // Stylesheet file only exists for external stylesheets\n            const filename = stylesheetFile ?? containingFile;\n\n            const stylesheetResult = await bundleComponentStylesheet(\n              styleOptions.inlineStyleLanguage,\n              data,\n              filename,\n              !stylesheetFile,\n              styleOptions,\n              pluginOptions.loadResultCache,\n            );\n\n            const { contents, resourceFiles, errors, warnings } = stylesheetResult;\n            if (errors) {\n              (result.errors ??= []).push(...errors);\n            }\n            (result.warnings ??= []).push(...warnings);\n            stylesheetResourceFiles.push(...resourceFiles);\n            if (stylesheetResult.metafile) {\n              stylesheetMetafiles.push(stylesheetResult.metafile);\n            }\n\n            return contents;\n          },\n        };\n\n        // Initialize the Angular compilation for the current build.\n        // In watch mode, previous build state will be reused.\n        const {\n          affectedFiles,\n          compilerOptions: { allowJs },\n        } = await compilation.initialize(tsconfigPath, hostOptions, (compilerOptions) => {\n          if (\n            compilerOptions.target === undefined ||\n            compilerOptions.target < ts.ScriptTarget.ES2022\n          ) {\n            // If 'useDefineForClassFields' is already defined in the users project leave the value as is.\n            // Otherwise fallback to false due to https://github.com/microsoft/TypeScript/issues/45995\n            // which breaks the deprecated `@Effects` NGRX decorator and potentially other existing code as well.\n            compilerOptions.target = ts.ScriptTarget.ES2022;\n            compilerOptions.useDefineForClassFields ??= false;\n\n            // Only add the warning on the initial build\n            setupWarnings?.push({\n              text:\n                'TypeScript compiler options \"target\" and \"useDefineForClassFields\" are set to \"ES2022\" and ' +\n                '\"false\" respectively by the Angular CLI.',\n              location: { file: pluginOptions.tsconfig },\n              notes: [\n                {\n                  text:\n                    'To control ECMA version and features use the Browerslist configuration. ' +\n                    'For more information, see https://angular.io/guide/build#configuring-browser-compatibility',\n                },\n              ],\n            });\n          }\n\n          return {\n            ...compilerOptions,\n            noEmitOnError: false,\n            inlineSources: pluginOptions.sourcemap,\n            inlineSourceMap: pluginOptions.sourcemap,\n            mapRoot: undefined,\n            sourceRoot: undefined,\n            preserveSymlinks,\n          };\n        });\n        shouldTsIgnoreJs = !allowJs;\n\n        // Clear affected files from the cache (if present)\n        if (pluginOptions.sourceFileCache) {\n          for (const affected of affectedFiles) {\n            pluginOptions.sourceFileCache.typeScriptFileCache.delete(\n              pathToFileURL(affected.fileName).href,\n            );\n          }\n        }\n\n        profileSync('NG_DIAGNOSTICS_TOTAL', () => {\n          for (const diagnostic of compilation.collectDiagnostics()) {\n            const message = convertTypeScriptDiagnostic(diagnostic);\n            if (diagnostic.category === ts.DiagnosticCategory.Error) {\n              (result.errors ??= []).push(message);\n            } else {\n              (result.warnings ??= []).push(message);\n            }\n          }\n        });\n\n        fileEmitter = compilation.createFileEmitter();\n\n        // Reset the setup warnings so that they are only shown during the first build.\n        setupWarnings = undefined;\n\n        return result;\n      });\n\n      build.onLoad({ filter: /\\.[cm]?[jt]sx?$/ }, (args) =>\n        profileAsync(\n          'NG_EMIT_TS*',\n          async () => {\n            assert.ok(fileEmitter, 'Invalid plugin execution order');\n\n            const request = pluginOptions.fileReplacements?.[args.path] ?? args.path;\n\n            // Skip TS load attempt if JS TypeScript compilation not enabled and file is JS\n            if (shouldTsIgnoreJs && /\\.[cm]?js$/.test(request)) {\n              return undefined;\n            }\n\n            // The filename is currently used as a cache key. Since the cache is memory only,\n            // the options cannot change and do not need to be represented in the key. If the\n            // cache is later stored to disk, then the options that affect transform output\n            // would need to be added to the key as well as a check for any change of content.\n            let contents = pluginOptions.sourceFileCache?.typeScriptFileCache.get(\n              pathToFileURL(request).href,\n            );\n\n            if (contents === undefined) {\n              const typescriptResult = await fileEmitter(request);\n              if (!typescriptResult?.content) {\n                // No TS result indicates the file is not part of the TypeScript program.\n                // If allowJs is enabled and the file is JS then defer to the next load hook.\n                if (!shouldTsIgnoreJs && /\\.[cm]?js$/.test(request)) {\n                  return undefined;\n                }\n\n                // Otherwise return an error\n                return {\n                  errors: [\n                    createMissingFileError(\n                      request,\n                      args.path,\n                      build.initialOptions.absWorkingDir ?? '',\n                    ),\n                  ],\n                };\n              }\n\n              contents = await javascriptTransformer.transformData(\n                request,\n                typescriptResult.content,\n                true /* skipLinker */,\n              );\n\n              pluginOptions.sourceFileCache?.typeScriptFileCache.set(\n                pathToFileURL(request).href,\n                contents,\n              );\n            }\n\n            return {\n              contents,\n              loader: 'js',\n            };\n          },\n          true,\n        ),\n      );\n\n      build.onLoad({ filter: /\\.[cm]?js$/ }, (args) =>\n        profileAsync(\n          'NG_EMIT_JS*',\n          async () => {\n            // The filename is currently used as a cache key. Since the cache is memory only,\n            // the options cannot change and do not need to be represented in the key. If the\n            // cache is later stored to disk, then the options that affect transform output\n            // would need to be added to the key as well as a check for any change of content.\n            let contents = pluginOptions.sourceFileCache?.babelFileCache.get(args.path);\n            if (contents === undefined) {\n              contents = await javascriptTransformer.transformFile(args.path, pluginOptions.jit);\n              pluginOptions.sourceFileCache?.babelFileCache.set(args.path, contents);\n            }\n\n            return {\n              contents,\n              loader: 'js',\n            };\n          },\n          true,\n        ),\n      );\n\n      // Setup bundling of component templates and stylesheets when in JIT mode\n      if (pluginOptions.jit) {\n        setupJitPluginCallbacks(\n          build,\n          styleOptions,\n          stylesheetResourceFiles,\n          pluginOptions.loadResultCache,\n        );\n      }\n\n      build.onEnd((result) => {\n        // Add any component stylesheet resource files to the output files\n        if (stylesheetResourceFiles.length) {\n          result.outputFiles?.push(...stylesheetResourceFiles);\n        }\n\n        // Combine component stylesheet metafiles with main metafile\n        if (result.metafile && stylesheetMetafiles.length) {\n          for (const metafile of stylesheetMetafiles) {\n            result.metafile.inputs = { ...result.metafile.inputs, ...metafile.inputs };\n            result.metafile.outputs = { ...result.metafile.outputs, ...metafile.outputs };\n          }\n        }\n\n        logCumulativeDurations();\n      });\n    },\n  };\n}\n\nfunction createMissingFileError(request: string, original: string, root: string): PartialMessage {\n  const error = {\n    text: `File '${path.relative(root, request)}' is missing from the TypeScript compilation.`,\n    notes: [\n      {\n        text: `Ensure the file is part of the TypeScript program via the 'files' or 'include' property.`,\n      },\n    ],\n  };\n\n  if (request !== original) {\n    error.notes.push({\n      text: `File is requested from a file replacement of '${path.relative(root, original)}'.`,\n    });\n  }\n\n  return error;\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/angular/diagnostics.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/angular/diagnostics.d.ts new file mode 100644 index 00000000..8bc07eab --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/angular/diagnostics.d.ts @@ -0,0 +1,15 @@ +/** + * @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 type { PartialMessage } from 'esbuild'; +import { Diagnostic } from 'typescript'; +/** + * Converts a TypeScript Diagnostic message into an esbuild compatible message object. + * @param diagnostic The TypeScript diagnostic to convert. + * @returns An esbuild diagnostic message as a PartialMessage object + */ +export declare function convertTypeScriptDiagnostic(diagnostic: Diagnostic): PartialMessage; diff --git a/artifacts/build-angular/src/builders/browser-esbuild/angular/diagnostics.js b/artifacts/build-angular/src/builders/browser-esbuild/angular/diagnostics.js new file mode 100644 index 00000000..aef8db7e --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/angular/diagnostics.js @@ -0,0 +1,75 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.convertTypeScriptDiagnostic = void 0; +const node_os_1 = require("node:os"); +const typescript_1 = require("typescript"); +/** + * Converts TypeScript Diagnostic related information into an esbuild compatible note object. + * Related information is a subset of a full TypeScript Diagnostic and also used for diagnostic + * notes associated with the main Diagnostic. + * @param info The TypeScript diagnostic relative information to convert. + * @returns An esbuild diagnostic message as a PartialMessage object + */ +function convertTypeScriptDiagnosticInfo(info, textPrefix) { + const newLine = (0, node_os_1.platform)() === 'win32' ? '\r\n' : '\n'; + let text = (0, typescript_1.flattenDiagnosticMessageText)(info.messageText, newLine); + if (textPrefix) { + text = textPrefix + text; + } + const note = { text }; + if (info.file) { + note.location = { + file: info.file.fileName, + length: info.length, + }; + // Calculate the line/column location and extract the full line text that has the diagnostic + if (info.start) { + const { line, character } = (0, typescript_1.getLineAndCharacterOfPosition)(info.file, info.start); + note.location.line = line + 1; + note.location.column = character; + // The start position for the slice is the first character of the error line + const lineStartPosition = (0, typescript_1.getPositionOfLineAndCharacter)(info.file, line, 0); + // The end position for the slice is the first character of the next line or the length of + // the entire file if the line is the last line of the file (getPositionOfLineAndCharacter + // will error if a nonexistent line is passed). + const { line: lastLineOfFile } = (0, typescript_1.getLineAndCharacterOfPosition)(info.file, info.file.text.length - 1); + const lineEndPosition = line < lastLineOfFile + ? (0, typescript_1.getPositionOfLineAndCharacter)(info.file, line + 1, 0) + : info.file.text.length; + note.location.lineText = info.file.text.slice(lineStartPosition, lineEndPosition).trimEnd(); + } + } + return note; +} +/** + * Converts a TypeScript Diagnostic message into an esbuild compatible message object. + * @param diagnostic The TypeScript diagnostic to convert. + * @returns An esbuild diagnostic message as a PartialMessage object + */ +function convertTypeScriptDiagnostic(diagnostic) { + let codePrefix = 'TS'; + let code = `${diagnostic.code}`; + if (diagnostic.source === 'ngtsc') { + codePrefix = 'NG'; + // Remove `-99` Angular prefix from diagnostic code + code = code.slice(3); + } + const message = { + ...convertTypeScriptDiagnosticInfo(diagnostic, `${codePrefix}${code}: `), + // Store original diagnostic for reference if needed downstream + detail: diagnostic, + }; + if (diagnostic.relatedInformation?.length) { + message.notes = diagnostic.relatedInformation.map((info) => convertTypeScriptDiagnosticInfo(info)); + } + return message; +} +exports.convertTypeScriptDiagnostic = convertTypeScriptDiagnostic; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/angular/jit-compilation.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/angular/jit-compilation.d.ts new file mode 100644 index 00000000..448a8a5a --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/angular/jit-compilation.d.ts @@ -0,0 +1,20 @@ +/** + * @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 type ng from '@angular/compiler-cli'; +import ts from 'typescript'; +import { AngularCompilation, FileEmitter } from './angular-compilation'; +import { AngularHostOptions } from './angular-host'; +export declare class JitCompilation extends AngularCompilation { + #private; + initialize(tsconfig: string, hostOptions: AngularHostOptions, compilerOptionsTransformer?: (compilerOptions: ng.CompilerOptions) => ng.CompilerOptions): Promise<{ + affectedFiles: ReadonlySet; + compilerOptions: ng.CompilerOptions; + }>; + collectDiagnostics(): Iterable; + createFileEmitter(onAfterEmit?: (sourceFile: ts.SourceFile) => void): FileEmitter; +} diff --git a/artifacts/build-angular/src/builders/browser-esbuild/angular/jit-compilation.js b/artifacts/build-angular/src/builders/browser-esbuild/angular/jit-compilation.js new file mode 100644 index 00000000..cb849e19 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/angular/jit-compilation.js @@ -0,0 +1,100 @@ +"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 __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +}; +var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) { + if (kind === "m") throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +var _JitCompilation_state; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.JitCompilation = void 0; +const node_assert_1 = __importDefault(require("node:assert")); +const typescript_1 = __importDefault(require("typescript")); +const profiling_1 = require("../profiling"); +const angular_compilation_1 = require("./angular-compilation"); +const angular_host_1 = require("./angular-host"); +const jit_resource_transformer_1 = require("./jit-resource-transformer"); +class JitCompilationState { + constructor(typeScriptProgram, constructorParametersDownlevelTransform, replaceResourcesTransform) { + this.typeScriptProgram = typeScriptProgram; + this.constructorParametersDownlevelTransform = constructorParametersDownlevelTransform; + this.replaceResourcesTransform = replaceResourcesTransform; + } +} +class JitCompilation extends angular_compilation_1.AngularCompilation { + constructor() { + super(...arguments); + _JitCompilation_state.set(this, void 0); + } + async initialize(tsconfig, hostOptions, compilerOptionsTransformer) { + // Dynamically load the Angular compiler CLI package + const { constructorParametersDownlevelTransform } = await angular_compilation_1.AngularCompilation.loadCompilerCli(); + // Load the compiler configuration and transform as needed + const { options: originalCompilerOptions, rootNames, errors: configurationDiagnostics, } = await this.loadConfiguration(tsconfig); + const compilerOptions = compilerOptionsTransformer?.(originalCompilerOptions) ?? originalCompilerOptions; + // Create Angular compiler host + const host = (0, angular_host_1.createAngularCompilerHost)(compilerOptions, hostOptions); + // Create the TypeScript Program + const typeScriptProgram = (0, profiling_1.profileSync)('TS_CREATE_PROGRAM', () => typescript_1.default.createEmitAndSemanticDiagnosticsBuilderProgram(rootNames, compilerOptions, host, __classPrivateFieldGet(this, _JitCompilation_state, "f")?.typeScriptProgram, configurationDiagnostics)); + const affectedFiles = (0, profiling_1.profileSync)('TS_FIND_AFFECTED', () => findAffectedFiles(typeScriptProgram)); + __classPrivateFieldSet(this, _JitCompilation_state, new JitCompilationState(typeScriptProgram, constructorParametersDownlevelTransform(typeScriptProgram.getProgram()), (0, jit_resource_transformer_1.createJitResourceTransformer)(() => typeScriptProgram.getProgram().getTypeChecker())), "f"); + return { affectedFiles, compilerOptions }; + } + *collectDiagnostics() { + (0, node_assert_1.default)(__classPrivateFieldGet(this, _JitCompilation_state, "f"), 'Compilation must be initialized prior to collecting diagnostics.'); + const { typeScriptProgram } = __classPrivateFieldGet(this, _JitCompilation_state, "f"); + // Collect program level diagnostics + yield* typeScriptProgram.getConfigFileParsingDiagnostics(); + yield* typeScriptProgram.getOptionsDiagnostics(); + yield* typeScriptProgram.getGlobalDiagnostics(); + yield* (0, profiling_1.profileSync)('NG_DIAGNOSTICS_SYNTACTIC', () => typeScriptProgram.getSyntacticDiagnostics()); + yield* (0, profiling_1.profileSync)('NG_DIAGNOSTICS_SEMANTIC', () => typeScriptProgram.getSemanticDiagnostics()); + } + createFileEmitter(onAfterEmit) { + (0, node_assert_1.default)(__classPrivateFieldGet(this, _JitCompilation_state, "f"), 'Compilation must be initialized prior to emitting files.'); + const { typeScriptProgram, constructorParametersDownlevelTransform, replaceResourcesTransform, } = __classPrivateFieldGet(this, _JitCompilation_state, "f"); + const transformers = { + before: [replaceResourcesTransform, constructorParametersDownlevelTransform], + }; + return async (file) => { + const sourceFile = typeScriptProgram.getSourceFile(file); + if (!sourceFile) { + return undefined; + } + let content; + typeScriptProgram.emit(sourceFile, (filename, data) => { + if (/\.[cm]?js$/.test(filename)) { + content = data; + } + }, undefined /* cancellationToken */, undefined /* emitOnlyDtsFiles */, transformers); + onAfterEmit?.(sourceFile); + return { content, dependencies: [] }; + }; + } +} +exports.JitCompilation = JitCompilation; +_JitCompilation_state = new WeakMap(); +function findAffectedFiles(builder) { + const affectedFiles = new Set(); + let result; + while ((result = builder.getSemanticDiagnosticsOfNextAffectedFile())) { + affectedFiles.add(result.affected); + } + return affectedFiles; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jit-compilation.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/angular/jit-compilation.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 type ng from '@angular/compiler-cli';\nimport assert from 'node:assert';\nimport ts from 'typescript';\nimport { profileSync } from '../profiling';\nimport { AngularCompilation, FileEmitter } from './angular-compilation';\nimport { AngularHostOptions, createAngularCompilerHost } from './angular-host';\nimport { createJitResourceTransformer } from './jit-resource-transformer';\n\nclass JitCompilationState {\n  constructor(\n    public readonly typeScriptProgram: ts.EmitAndSemanticDiagnosticsBuilderProgram,\n    public readonly constructorParametersDownlevelTransform: ts.TransformerFactory<ts.SourceFile>,\n    public readonly replaceResourcesTransform: ts.TransformerFactory<ts.SourceFile>,\n  ) {}\n}\n\nexport class JitCompilation extends AngularCompilation {\n  #state?: JitCompilationState;\n\n  async initialize(\n    tsconfig: string,\n    hostOptions: AngularHostOptions,\n    compilerOptionsTransformer?: (compilerOptions: ng.CompilerOptions) => ng.CompilerOptions,\n  ): Promise<{ affectedFiles: ReadonlySet<ts.SourceFile>; compilerOptions: ng.CompilerOptions }> {\n    // Dynamically load the Angular compiler CLI package\n    const { constructorParametersDownlevelTransform } = await AngularCompilation.loadCompilerCli();\n\n    // Load the compiler configuration and transform as needed\n    const {\n      options: originalCompilerOptions,\n      rootNames,\n      errors: configurationDiagnostics,\n    } = await this.loadConfiguration(tsconfig);\n    const compilerOptions =\n      compilerOptionsTransformer?.(originalCompilerOptions) ?? originalCompilerOptions;\n\n    // Create Angular compiler host\n    const host = createAngularCompilerHost(compilerOptions, hostOptions);\n\n    // Create the TypeScript Program\n    const typeScriptProgram = profileSync('TS_CREATE_PROGRAM', () =>\n      ts.createEmitAndSemanticDiagnosticsBuilderProgram(\n        rootNames,\n        compilerOptions,\n        host,\n        this.#state?.typeScriptProgram,\n        configurationDiagnostics,\n      ),\n    );\n\n    const affectedFiles = profileSync('TS_FIND_AFFECTED', () =>\n      findAffectedFiles(typeScriptProgram),\n    );\n\n    this.#state = new JitCompilationState(\n      typeScriptProgram,\n      constructorParametersDownlevelTransform(typeScriptProgram.getProgram()),\n      createJitResourceTransformer(() => typeScriptProgram.getProgram().getTypeChecker()),\n    );\n\n    return { affectedFiles, compilerOptions };\n  }\n\n  *collectDiagnostics(): Iterable<ts.Diagnostic> {\n    assert(this.#state, 'Compilation must be initialized prior to collecting diagnostics.');\n    const { typeScriptProgram } = this.#state;\n\n    // Collect program level diagnostics\n    yield* typeScriptProgram.getConfigFileParsingDiagnostics();\n    yield* typeScriptProgram.getOptionsDiagnostics();\n    yield* typeScriptProgram.getGlobalDiagnostics();\n    yield* profileSync('NG_DIAGNOSTICS_SYNTACTIC', () =>\n      typeScriptProgram.getSyntacticDiagnostics(),\n    );\n    yield* profileSync('NG_DIAGNOSTICS_SEMANTIC', () => typeScriptProgram.getSemanticDiagnostics());\n  }\n\n  createFileEmitter(onAfterEmit?: (sourceFile: ts.SourceFile) => void): FileEmitter {\n    assert(this.#state, 'Compilation must be initialized prior to emitting files.');\n    const {\n      typeScriptProgram,\n      constructorParametersDownlevelTransform,\n      replaceResourcesTransform,\n    } = this.#state;\n\n    const transformers = {\n      before: [replaceResourcesTransform, constructorParametersDownlevelTransform],\n    };\n\n    return async (file: string) => {\n      const sourceFile = typeScriptProgram.getSourceFile(file);\n      if (!sourceFile) {\n        return undefined;\n      }\n\n      let content: string | undefined;\n      typeScriptProgram.emit(\n        sourceFile,\n        (filename, data) => {\n          if (/\\.[cm]?js$/.test(filename)) {\n            content = data;\n          }\n        },\n        undefined /* cancellationToken */,\n        undefined /* emitOnlyDtsFiles */,\n        transformers,\n      );\n\n      onAfterEmit?.(sourceFile);\n\n      return { content, dependencies: [] };\n    };\n  }\n}\n\nfunction findAffectedFiles(\n  builder: ts.EmitAndSemanticDiagnosticsBuilderProgram,\n): Set<ts.SourceFile> {\n  const affectedFiles = new Set<ts.SourceFile>();\n\n  let result;\n  while ((result = builder.getSemanticDiagnosticsOfNextAffectedFile())) {\n    affectedFiles.add(result.affected as ts.SourceFile);\n  }\n\n  return affectedFiles;\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/angular/jit-plugin-callbacks.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/angular/jit-plugin-callbacks.d.ts new file mode 100644 index 00000000..813de4c5 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/angular/jit-plugin-callbacks.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 type { OutputFile, PluginBuild } from 'esbuild'; +import { LoadResultCache } from '../load-result-cache'; +import { BundleStylesheetOptions } from '../stylesheets/bundle-options'; +/** + * Sets up esbuild resolve and load callbacks to support Angular JIT mode processing + * for both Component stylesheets and templates. These callbacks work alongside the JIT + * resource TypeScript transformer to convert and then bundle Component resources as + * static imports. + * @param build An esbuild {@link PluginBuild} instance used to add callbacks. + * @param styleOptions The options to use when bundling stylesheets. + * @param stylesheetResourceFiles An array where stylesheet resources will be added. + */ +export declare function setupJitPluginCallbacks(build: PluginBuild, styleOptions: BundleStylesheetOptions & { + inlineStyleLanguage: string; +}, stylesheetResourceFiles: OutputFile[], cache?: LoadResultCache): void; diff --git a/artifacts/build-angular/src/builders/browser-esbuild/angular/jit-plugin-callbacks.js b/artifacts/build-angular/src/builders/browser-esbuild/angular/jit-plugin-callbacks.js new file mode 100644 index 00000000..3d713c4a --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/angular/jit-plugin-callbacks.js @@ -0,0 +1,113 @@ +"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 __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.setupJitPluginCallbacks = void 0; +const promises_1 = require("node:fs/promises"); +const node_path_1 = __importDefault(require("node:path")); +const bundle_options_1 = require("../stylesheets/bundle-options"); +const uri_1 = require("./uri"); +/** + * Loads/extracts the contents from a load callback Angular JIT entry. + * An Angular JIT entry represents either a file path for a component resource or base64 + * encoded data for an inline component resource. + * @param entry The value that represents content to load. + * @param root The absolute path for the root of the build (typically the workspace root). + * @param skipRead If true, do not attempt to read the file; if false, read file content from disk. + * This option has no effect if the entry does not originate from a file. Defaults to false. + * @returns An object containing the absolute path of the contents and optionally the actual contents. + * For inline entries the contents will always be provided. + */ +async function loadEntry(entry, root, skipRead) { + if (entry.startsWith('file:')) { + const specifier = node_path_1.default.join(root, entry.slice(5)); + return { + path: specifier, + contents: skipRead ? undefined : await (0, promises_1.readFile)(specifier, 'utf-8'), + }; + } + else if (entry.startsWith('inline:')) { + const [importer, data] = entry.slice(7).split(';', 2); + return { + path: node_path_1.default.join(root, importer), + contents: Buffer.from(data, 'base64').toString(), + }; + } + else { + throw new Error('Invalid data for Angular JIT entry.'); + } +} +/** + * Sets up esbuild resolve and load callbacks to support Angular JIT mode processing + * for both Component stylesheets and templates. These callbacks work alongside the JIT + * resource TypeScript transformer to convert and then bundle Component resources as + * static imports. + * @param build An esbuild {@link PluginBuild} instance used to add callbacks. + * @param styleOptions The options to use when bundling stylesheets. + * @param stylesheetResourceFiles An array where stylesheet resources will be added. + */ +function setupJitPluginCallbacks(build, styleOptions, stylesheetResourceFiles, cache) { + const root = build.initialOptions.absWorkingDir ?? ''; + // Add a resolve callback to capture and parse any JIT URIs that were added by the + // JIT resource TypeScript transformer. + // Resources originating from a file are resolved as relative from the containing file (importer). + build.onResolve({ filter: uri_1.JIT_NAMESPACE_REGEXP }, (args) => { + const parsed = (0, uri_1.parseJitUri)(args.path); + if (!parsed) { + return undefined; + } + const { namespace, origin, specifier } = parsed; + if (origin === 'file') { + return { + // Use a relative path to prevent fully resolved paths in the metafile (JSON stats file). + // This is only necessary for custom namespaces. esbuild will handle the file namespace. + path: 'file:' + node_path_1.default.relative(root, node_path_1.default.join(node_path_1.default.dirname(args.importer), specifier)), + namespace, + }; + } + else { + // Inline data may need the importer to resolve imports/references within the content + const importer = node_path_1.default.relative(root, args.importer); + return { + path: `inline:${importer};${specifier}`, + namespace, + }; + } + }); + // Add a load callback to handle Component stylesheets (both inline and external) + build.onLoad({ filter: /./, namespace: uri_1.JIT_STYLE_NAMESPACE }, async (args) => { + // skipRead is used here because the stylesheet bundling will read a file stylesheet + // directly either via a preprocessor or esbuild itself. + const entry = await loadEntry(args.path, root, true /* skipRead */); + const { contents, resourceFiles, errors, warnings } = await (0, bundle_options_1.bundleComponentStylesheet)(styleOptions.inlineStyleLanguage, + // The `data` parameter is only needed for a stylesheet if it was inline + entry.contents ?? '', entry.path, entry.contents !== undefined, styleOptions, cache); + stylesheetResourceFiles.push(...resourceFiles); + return { + errors, + warnings, + contents, + loader: 'text', + }; + }); + // Add a load callback to handle Component templates + // NOTE: While this callback supports both inline and external templates, the transformer + // currently only supports generating URIs for external templates. + build.onLoad({ filter: /./, namespace: uri_1.JIT_TEMPLATE_NAMESPACE }, async (args) => { + const { contents } = await loadEntry(args.path, root); + return { + contents, + loader: 'text', + }; + }); +} +exports.setupJitPluginCallbacks = setupJitPluginCallbacks; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jit-plugin-callbacks.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/angular/jit-plugin-callbacks.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 type { OutputFile, PluginBuild } from 'esbuild';\nimport { readFile } from 'node:fs/promises';\nimport path from 'node:path';\nimport { LoadResultCache } from '../load-result-cache';\nimport { BundleStylesheetOptions, bundleComponentStylesheet } from '../stylesheets/bundle-options';\nimport {\n  JIT_NAMESPACE_REGEXP,\n  JIT_STYLE_NAMESPACE,\n  JIT_TEMPLATE_NAMESPACE,\n  parseJitUri,\n} from './uri';\n\n/**\n * Loads/extracts the contents from a load callback Angular JIT entry.\n * An Angular JIT entry represents either a file path for a component resource or base64\n * encoded data for an inline component resource.\n * @param entry The value that represents content to load.\n * @param root The absolute path for the root of the build (typically the workspace root).\n * @param skipRead If true, do not attempt to read the file; if false, read file content from disk.\n * This option has no effect if the entry does not originate from a file. Defaults to false.\n * @returns An object containing the absolute path of the contents and optionally the actual contents.\n * For inline entries the contents will always be provided.\n */\nasync function loadEntry(\n  entry: string,\n  root: string,\n  skipRead?: boolean,\n): Promise<{ path: string; contents?: string }> {\n  if (entry.startsWith('file:')) {\n    const specifier = path.join(root, entry.slice(5));\n\n    return {\n      path: specifier,\n      contents: skipRead ? undefined : await readFile(specifier, 'utf-8'),\n    };\n  } else if (entry.startsWith('inline:')) {\n    const [importer, data] = entry.slice(7).split(';', 2);\n\n    return {\n      path: path.join(root, importer),\n      contents: Buffer.from(data, 'base64').toString(),\n    };\n  } else {\n    throw new Error('Invalid data for Angular JIT entry.');\n  }\n}\n\n/**\n * Sets up esbuild resolve and load callbacks to support Angular JIT mode processing\n * for both Component stylesheets and templates. These callbacks work alongside the JIT\n * resource TypeScript transformer to convert and then bundle Component resources as\n * static imports.\n * @param build An esbuild {@link PluginBuild} instance used to add callbacks.\n * @param styleOptions The options to use when bundling stylesheets.\n * @param stylesheetResourceFiles An array where stylesheet resources will be added.\n */\nexport function setupJitPluginCallbacks(\n  build: PluginBuild,\n  styleOptions: BundleStylesheetOptions & { inlineStyleLanguage: string },\n  stylesheetResourceFiles: OutputFile[],\n  cache?: LoadResultCache,\n): void {\n  const root = build.initialOptions.absWorkingDir ?? '';\n\n  // Add a resolve callback to capture and parse any JIT URIs that were added by the\n  // JIT resource TypeScript transformer.\n  // Resources originating from a file are resolved as relative from the containing file (importer).\n  build.onResolve({ filter: JIT_NAMESPACE_REGEXP }, (args) => {\n    const parsed = parseJitUri(args.path);\n    if (!parsed) {\n      return undefined;\n    }\n\n    const { namespace, origin, specifier } = parsed;\n\n    if (origin === 'file') {\n      return {\n        // Use a relative path to prevent fully resolved paths in the metafile (JSON stats file).\n        // This is only necessary for custom namespaces. esbuild will handle the file namespace.\n        path: 'file:' + path.relative(root, path.join(path.dirname(args.importer), specifier)),\n        namespace,\n      };\n    } else {\n      // Inline data may need the importer to resolve imports/references within the content\n      const importer = path.relative(root, args.importer);\n\n      return {\n        path: `inline:${importer};${specifier}`,\n        namespace,\n      };\n    }\n  });\n\n  // Add a load callback to handle Component stylesheets (both inline and external)\n  build.onLoad({ filter: /./, namespace: JIT_STYLE_NAMESPACE }, async (args) => {\n    // skipRead is used here because the stylesheet bundling will read a file stylesheet\n    // directly either via a preprocessor or esbuild itself.\n    const entry = await loadEntry(args.path, root, true /* skipRead */);\n\n    const { contents, resourceFiles, errors, warnings } = await bundleComponentStylesheet(\n      styleOptions.inlineStyleLanguage,\n      // The `data` parameter is only needed for a stylesheet if it was inline\n      entry.contents ?? '',\n      entry.path,\n      entry.contents !== undefined,\n      styleOptions,\n      cache,\n    );\n\n    stylesheetResourceFiles.push(...resourceFiles);\n\n    return {\n      errors,\n      warnings,\n      contents,\n      loader: 'text',\n    };\n  });\n\n  // Add a load callback to handle Component templates\n  // NOTE: While this callback supports both inline and external templates, the transformer\n  // currently only supports generating URIs for external templates.\n  build.onLoad({ filter: /./, namespace: JIT_TEMPLATE_NAMESPACE }, async (args) => {\n    const { contents } = await loadEntry(args.path, root);\n\n    return {\n      contents,\n      loader: 'text',\n    };\n  });\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/angular/jit-resource-transformer.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/angular/jit-resource-transformer.d.ts new file mode 100644 index 00000000..691bd722 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/angular/jit-resource-transformer.d.ts @@ -0,0 +1,17 @@ +/** + * @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 ts from 'typescript'; +/** + * Creates a TypeScript Transformer to transform Angular Component resource references into + * static import statements. This transformer is used in Angular's JIT compilation mode to + * support processing of component resources. When in AOT mode, the Angular AOT compiler handles + * this processing and this transformer is not used. + * @param getTypeChecker A function that returns a TypeScript TypeChecker instance for the program. + * @returns A TypeScript transformer factory. + */ +export declare function createJitResourceTransformer(getTypeChecker: () => ts.TypeChecker): ts.TransformerFactory; diff --git a/artifacts/build-angular/src/builders/browser-esbuild/angular/jit-resource-transformer.js b/artifacts/build-angular/src/builders/browser-esbuild/angular/jit-resource-transformer.js new file mode 100644 index 00000000..50ca0ffc --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/angular/jit-resource-transformer.js @@ -0,0 +1,185 @@ +"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 __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createJitResourceTransformer = void 0; +const typescript_1 = __importDefault(require("typescript")); +const uri_1 = require("./uri"); +/** + * Creates a TypeScript Transformer to transform Angular Component resource references into + * static import statements. This transformer is used in Angular's JIT compilation mode to + * support processing of component resources. When in AOT mode, the Angular AOT compiler handles + * this processing and this transformer is not used. + * @param getTypeChecker A function that returns a TypeScript TypeChecker instance for the program. + * @returns A TypeScript transformer factory. + */ +function createJitResourceTransformer(getTypeChecker) { + return (context) => { + const typeChecker = getTypeChecker(); + const nodeFactory = context.factory; + const resourceImportDeclarations = []; + const visitNode = (node) => { + if (typescript_1.default.isClassDeclaration(node)) { + const decorators = typescript_1.default.getDecorators(node); + if (!decorators || decorators.length === 0) { + return node; + } + return nodeFactory.updateClassDeclaration(node, [ + ...decorators.map((current) => visitDecorator(nodeFactory, current, typeChecker, resourceImportDeclarations)), + ...(typescript_1.default.getModifiers(node) ?? []), + ], node.name, node.typeParameters, node.heritageClauses, node.members); + } + return typescript_1.default.visitEachChild(node, visitNode, context); + }; + return (sourceFile) => { + const updatedSourceFile = typescript_1.default.visitEachChild(sourceFile, visitNode, context); + if (resourceImportDeclarations.length > 0) { + return nodeFactory.updateSourceFile(updatedSourceFile, typescript_1.default.setTextRange(nodeFactory.createNodeArray([...resourceImportDeclarations, ...updatedSourceFile.statements], updatedSourceFile.statements.hasTrailingComma), updatedSourceFile.statements), updatedSourceFile.isDeclarationFile, updatedSourceFile.referencedFiles, updatedSourceFile.typeReferenceDirectives, updatedSourceFile.hasNoDefaultLib, updatedSourceFile.libReferenceDirectives); + } + else { + return updatedSourceFile; + } + }; + }; +} +exports.createJitResourceTransformer = createJitResourceTransformer; +function visitDecorator(nodeFactory, node, typeChecker, resourceImportDeclarations) { + const origin = getDecoratorOrigin(node, typeChecker); + if (!origin || origin.module !== '@angular/core' || origin.name !== 'Component') { + return node; + } + if (!typescript_1.default.isCallExpression(node.expression)) { + return node; + } + const decoratorFactory = node.expression; + const args = decoratorFactory.arguments; + if (args.length !== 1 || !typescript_1.default.isObjectLiteralExpression(args[0])) { + // Unsupported component metadata + return node; + } + const objectExpression = args[0]; + const styleReplacements = []; + // visit all properties + let properties = typescript_1.default.visitNodes(objectExpression.properties, (node) => typescript_1.default.isObjectLiteralElementLike(node) + ? visitComponentMetadata(nodeFactory, node, styleReplacements, resourceImportDeclarations) + : node); + // replace properties with updated properties + if (styleReplacements.length > 0) { + const styleProperty = nodeFactory.createPropertyAssignment(nodeFactory.createIdentifier('styles'), nodeFactory.createArrayLiteralExpression(styleReplacements)); + properties = nodeFactory.createNodeArray([...properties, styleProperty]); + } + return nodeFactory.updateDecorator(node, nodeFactory.updateCallExpression(decoratorFactory, decoratorFactory.expression, decoratorFactory.typeArguments, [nodeFactory.updateObjectLiteralExpression(objectExpression, properties)])); +} +function visitComponentMetadata(nodeFactory, node, styleReplacements, resourceImportDeclarations) { + if (!typescript_1.default.isPropertyAssignment(node) || typescript_1.default.isComputedPropertyName(node.name)) { + return node; + } + switch (node.name.text) { + case 'templateUrl': + // Only analyze string literals + if (!typescript_1.default.isStringLiteral(node.initializer) && + !typescript_1.default.isNoSubstitutionTemplateLiteral(node.initializer)) { + return node; + } + const url = node.initializer.text; + if (!url) { + return node; + } + return nodeFactory.updatePropertyAssignment(node, nodeFactory.createIdentifier('template'), createResourceImport(nodeFactory, (0, uri_1.generateJitFileUri)(url, 'template'), resourceImportDeclarations)); + case 'styles': + if (!typescript_1.default.isArrayLiteralExpression(node.initializer)) { + return node; + } + const inlineStyles = typescript_1.default.visitNodes(node.initializer.elements, (node) => { + if (!typescript_1.default.isStringLiteral(node) && !typescript_1.default.isNoSubstitutionTemplateLiteral(node)) { + return node; + } + const contents = node.text; + if (!contents) { + // An empty inline style is equivalent to not having a style element + return undefined; + } + return createResourceImport(nodeFactory, (0, uri_1.generateJitInlineUri)(contents, 'style'), resourceImportDeclarations); + }); + // Inline styles should be placed first + styleReplacements.unshift(...inlineStyles); + // The inline styles will be added afterwards in combination with any external styles + return undefined; + case 'styleUrls': + if (!typescript_1.default.isArrayLiteralExpression(node.initializer)) { + return node; + } + const externalStyles = typescript_1.default.visitNodes(node.initializer.elements, (node) => { + if (!typescript_1.default.isStringLiteral(node) && !typescript_1.default.isNoSubstitutionTemplateLiteral(node)) { + return node; + } + const url = node.text; + if (!url) { + return node; + } + return createResourceImport(nodeFactory, (0, uri_1.generateJitFileUri)(url, 'style'), resourceImportDeclarations); + }); + // External styles are applied after any inline styles + styleReplacements.push(...externalStyles); + // The external styles will be added afterwards in combination with any inline styles + return undefined; + default: + // All other elements are passed through + return node; + } +} +function createResourceImport(nodeFactory, url, resourceImportDeclarations) { + const urlLiteral = nodeFactory.createStringLiteral(url); + const importName = nodeFactory.createIdentifier(`__NG_CLI_RESOURCE__${resourceImportDeclarations.length}`); + resourceImportDeclarations.push(nodeFactory.createImportDeclaration(undefined, nodeFactory.createImportClause(false, importName, undefined), urlLiteral)); + return importName; +} +function getDecoratorOrigin(decorator, typeChecker) { + if (!typescript_1.default.isCallExpression(decorator.expression)) { + return null; + } + let identifier; + let name = ''; + if (typescript_1.default.isPropertyAccessExpression(decorator.expression.expression)) { + identifier = decorator.expression.expression.expression; + name = decorator.expression.expression.name.text; + } + else if (typescript_1.default.isIdentifier(decorator.expression.expression)) { + identifier = decorator.expression.expression; + } + else { + return null; + } + // NOTE: resolver.getReferencedImportDeclaration would work as well but is internal + const symbol = typeChecker.getSymbolAtLocation(identifier); + if (symbol && symbol.declarations && symbol.declarations.length > 0) { + const declaration = symbol.declarations[0]; + let module; + if (typescript_1.default.isImportSpecifier(declaration)) { + name = (declaration.propertyName || declaration.name).text; + module = declaration.parent.parent.parent.moduleSpecifier.text; + } + else if (typescript_1.default.isNamespaceImport(declaration)) { + // Use the name from the decorator namespace property access + module = declaration.parent.parent.moduleSpecifier.text; + } + else if (typescript_1.default.isImportClause(declaration)) { + name = declaration.name.text; + module = declaration.parent.moduleSpecifier.text; + } + else { + return null; + } + return { name, module }; + } + return null; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jit-resource-transformer.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/angular/jit-resource-transformer.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 ts from 'typescript';\nimport { generateJitFileUri, generateJitInlineUri } from './uri';\n\n/**\n * Creates a TypeScript Transformer to transform Angular Component resource references into\n * static import statements. This transformer is used in Angular's JIT compilation mode to\n * support processing of component resources. When in AOT mode, the Angular AOT compiler handles\n * this processing and this transformer is not used.\n * @param getTypeChecker A function that returns a TypeScript TypeChecker instance for the program.\n * @returns A TypeScript transformer factory.\n */\nexport function createJitResourceTransformer(\n  getTypeChecker: () => ts.TypeChecker,\n): ts.TransformerFactory<ts.SourceFile> {\n  return (context: ts.TransformationContext) => {\n    const typeChecker = getTypeChecker();\n    const nodeFactory = context.factory;\n    const resourceImportDeclarations: ts.ImportDeclaration[] = [];\n\n    const visitNode: ts.Visitor = (node: ts.Node) => {\n      if (ts.isClassDeclaration(node)) {\n        const decorators = ts.getDecorators(node);\n\n        if (!decorators || decorators.length === 0) {\n          return node;\n        }\n\n        return nodeFactory.updateClassDeclaration(\n          node,\n          [\n            ...decorators.map((current) =>\n              visitDecorator(nodeFactory, current, typeChecker, resourceImportDeclarations),\n            ),\n            ...(ts.getModifiers(node) ?? []),\n          ],\n          node.name,\n          node.typeParameters,\n          node.heritageClauses,\n          node.members,\n        );\n      }\n\n      return ts.visitEachChild(node, visitNode, context);\n    };\n\n    return (sourceFile) => {\n      const updatedSourceFile = ts.visitEachChild(sourceFile, visitNode, context);\n\n      if (resourceImportDeclarations.length > 0) {\n        return nodeFactory.updateSourceFile(\n          updatedSourceFile,\n          ts.setTextRange(\n            nodeFactory.createNodeArray(\n              [...resourceImportDeclarations, ...updatedSourceFile.statements],\n              updatedSourceFile.statements.hasTrailingComma,\n            ),\n            updatedSourceFile.statements,\n          ),\n          updatedSourceFile.isDeclarationFile,\n          updatedSourceFile.referencedFiles,\n          updatedSourceFile.typeReferenceDirectives,\n          updatedSourceFile.hasNoDefaultLib,\n          updatedSourceFile.libReferenceDirectives,\n        );\n      } else {\n        return updatedSourceFile;\n      }\n    };\n  };\n}\n\nfunction visitDecorator(\n  nodeFactory: ts.NodeFactory,\n  node: ts.Decorator,\n  typeChecker: ts.TypeChecker,\n  resourceImportDeclarations: ts.ImportDeclaration[],\n): ts.Decorator {\n  const origin = getDecoratorOrigin(node, typeChecker);\n  if (!origin || origin.module !== '@angular/core' || origin.name !== 'Component') {\n    return node;\n  }\n\n  if (!ts.isCallExpression(node.expression)) {\n    return node;\n  }\n\n  const decoratorFactory = node.expression;\n  const args = decoratorFactory.arguments;\n  if (args.length !== 1 || !ts.isObjectLiteralExpression(args[0])) {\n    // Unsupported component metadata\n    return node;\n  }\n\n  const objectExpression = args[0] as ts.ObjectLiteralExpression;\n  const styleReplacements: ts.Expression[] = [];\n\n  // visit all properties\n  let properties = ts.visitNodes(objectExpression.properties, (node) =>\n    ts.isObjectLiteralElementLike(node)\n      ? visitComponentMetadata(nodeFactory, node, styleReplacements, resourceImportDeclarations)\n      : node,\n  ) as ts.NodeArray<ts.ObjectLiteralElementLike>;\n\n  // replace properties with updated properties\n  if (styleReplacements.length > 0) {\n    const styleProperty = nodeFactory.createPropertyAssignment(\n      nodeFactory.createIdentifier('styles'),\n      nodeFactory.createArrayLiteralExpression(styleReplacements),\n    );\n\n    properties = nodeFactory.createNodeArray([...properties, styleProperty]);\n  }\n\n  return nodeFactory.updateDecorator(\n    node,\n    nodeFactory.updateCallExpression(\n      decoratorFactory,\n      decoratorFactory.expression,\n      decoratorFactory.typeArguments,\n      [nodeFactory.updateObjectLiteralExpression(objectExpression, properties)],\n    ),\n  );\n}\n\nfunction visitComponentMetadata(\n  nodeFactory: ts.NodeFactory,\n  node: ts.ObjectLiteralElementLike,\n  styleReplacements: ts.Expression[],\n  resourceImportDeclarations: ts.ImportDeclaration[],\n): ts.ObjectLiteralElementLike | undefined {\n  if (!ts.isPropertyAssignment(node) || ts.isComputedPropertyName(node.name)) {\n    return node;\n  }\n\n  switch (node.name.text) {\n    case 'templateUrl':\n      // Only analyze string literals\n      if (\n        !ts.isStringLiteral(node.initializer) &&\n        !ts.isNoSubstitutionTemplateLiteral(node.initializer)\n      ) {\n        return node;\n      }\n\n      const url = node.initializer.text;\n      if (!url) {\n        return node;\n      }\n\n      return nodeFactory.updatePropertyAssignment(\n        node,\n        nodeFactory.createIdentifier('template'),\n        createResourceImport(\n          nodeFactory,\n          generateJitFileUri(url, 'template'),\n          resourceImportDeclarations,\n        ),\n      );\n    case 'styles':\n      if (!ts.isArrayLiteralExpression(node.initializer)) {\n        return node;\n      }\n\n      const inlineStyles = ts.visitNodes(node.initializer.elements, (node) => {\n        if (!ts.isStringLiteral(node) && !ts.isNoSubstitutionTemplateLiteral(node)) {\n          return node;\n        }\n\n        const contents = node.text;\n        if (!contents) {\n          // An empty inline style is equivalent to not having a style element\n          return undefined;\n        }\n\n        return createResourceImport(\n          nodeFactory,\n          generateJitInlineUri(contents, 'style'),\n          resourceImportDeclarations,\n        );\n      }) as ts.NodeArray<ts.Expression>;\n\n      // Inline styles should be placed first\n      styleReplacements.unshift(...inlineStyles);\n\n      // The inline styles will be added afterwards in combination with any external styles\n      return undefined;\n    case 'styleUrls':\n      if (!ts.isArrayLiteralExpression(node.initializer)) {\n        return node;\n      }\n\n      const externalStyles = ts.visitNodes(node.initializer.elements, (node) => {\n        if (!ts.isStringLiteral(node) && !ts.isNoSubstitutionTemplateLiteral(node)) {\n          return node;\n        }\n\n        const url = node.text;\n        if (!url) {\n          return node;\n        }\n\n        return createResourceImport(\n          nodeFactory,\n          generateJitFileUri(url, 'style'),\n          resourceImportDeclarations,\n        );\n      }) as ts.NodeArray<ts.Expression>;\n\n      // External styles are applied after any inline styles\n      styleReplacements.push(...externalStyles);\n\n      // The external styles will be added afterwards in combination with any inline styles\n      return undefined;\n    default:\n      // All other elements are passed through\n      return node;\n  }\n}\n\nfunction createResourceImport(\n  nodeFactory: ts.NodeFactory,\n  url: string,\n  resourceImportDeclarations: ts.ImportDeclaration[],\n): ts.Identifier {\n  const urlLiteral = nodeFactory.createStringLiteral(url);\n\n  const importName = nodeFactory.createIdentifier(\n    `__NG_CLI_RESOURCE__${resourceImportDeclarations.length}`,\n  );\n  resourceImportDeclarations.push(\n    nodeFactory.createImportDeclaration(\n      undefined,\n      nodeFactory.createImportClause(false, importName, undefined),\n      urlLiteral,\n    ),\n  );\n\n  return importName;\n}\n\nfunction getDecoratorOrigin(\n  decorator: ts.Decorator,\n  typeChecker: ts.TypeChecker,\n): { name: string; module: string } | null {\n  if (!ts.isCallExpression(decorator.expression)) {\n    return null;\n  }\n\n  let identifier: ts.Node;\n  let name = '';\n\n  if (ts.isPropertyAccessExpression(decorator.expression.expression)) {\n    identifier = decorator.expression.expression.expression;\n    name = decorator.expression.expression.name.text;\n  } else if (ts.isIdentifier(decorator.expression.expression)) {\n    identifier = decorator.expression.expression;\n  } else {\n    return null;\n  }\n\n  // NOTE: resolver.getReferencedImportDeclaration would work as well but is internal\n  const symbol = typeChecker.getSymbolAtLocation(identifier);\n  if (symbol && symbol.declarations && symbol.declarations.length > 0) {\n    const declaration = symbol.declarations[0];\n    let module: string;\n\n    if (ts.isImportSpecifier(declaration)) {\n      name = (declaration.propertyName || declaration.name).text;\n      module = (declaration.parent.parent.parent.moduleSpecifier as ts.StringLiteral).text;\n    } else if (ts.isNamespaceImport(declaration)) {\n      // Use the name from the decorator namespace property access\n      module = (declaration.parent.parent.moduleSpecifier as ts.StringLiteral).text;\n    } else if (ts.isImportClause(declaration)) {\n      name = (declaration.name as ts.Identifier).text;\n      module = (declaration.parent.moduleSpecifier as ts.StringLiteral).text;\n    } else {\n      return null;\n    }\n\n    return { name, module };\n  }\n\n  return null;\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/angular/uri.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/angular/uri.d.ts new file mode 100644 index 00000000..1e196036 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/angular/uri.d.ts @@ -0,0 +1,54 @@ +/** + * @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 + */ +/** + * A string value representing the namespace for Angular JIT mode related imports for + * Component styles. This namespace is used for both inline (`styles`) and external + * (`styleUrls`) styles. + */ +export declare const JIT_STYLE_NAMESPACE: "angular:jit:style"; +/** + * A string value representing the namespace for Angular JIT mode related imports for + * Component templates. This namespace is currently only used for external (`templateUrl`) + * templates. + */ +export declare const JIT_TEMPLATE_NAMESPACE: "angular:jit:template"; +/** + * A regular expression that can be used to match a Angular JIT mode namespace URI. + * It contains capture groups for the type (template/style), origin (file/inline), and specifier. + * The {@link parseJitUri} function can be used to parse and return an object representation of a JIT URI. + */ +export declare const JIT_NAMESPACE_REGEXP: RegExp; +/** + * Generates an Angular JIT mode namespace URI for a given file. + * @param file The path of the file to be included. + * @param type The type of the file (`style` or `template`). + * @returns A string containing the full JIT namespace URI. + */ +export declare function generateJitFileUri(file: string, type: 'style' | 'template'): string; +/** + * Generates an Angular JIT mode namespace URI for a given inline style or template. + * The provided content is base64 encoded and included in the URI. + * @param data The content to encode within the URI. + * @param type The type of the content (`style` or `template`). + * @returns A string containing the full JIT namespace URI. + */ +export declare function generateJitInlineUri(data: string | Uint8Array, type: 'style' | 'template'): string; +/** + * Parses a string containing a JIT namespace URI. + * JIT namespace URIs are used to encode the information for an Angular component's stylesheets + * and templates when compiled in JIT mode. + * @param uri The URI to parse into its underlying components. + * @returns An object containing the namespace, type, origin, and specifier of the URI; + * `undefined` if not a JIT namespace URI. + */ +export declare function parseJitUri(uri: string): { + namespace: string; + type: "style" | "template"; + origin: "inline" | "file"; + specifier: string; +} | undefined; diff --git a/artifacts/build-angular/src/builders/browser-esbuild/angular/uri.js b/artifacts/build-angular/src/builders/browser-esbuild/angular/uri.js new file mode 100644 index 00000000..43077950 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/angular/uri.js @@ -0,0 +1,75 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parseJitUri = exports.generateJitInlineUri = exports.generateJitFileUri = exports.JIT_NAMESPACE_REGEXP = exports.JIT_TEMPLATE_NAMESPACE = exports.JIT_STYLE_NAMESPACE = void 0; +/** + * A string value representing the base namespace for Angular JIT mode related imports. + */ +const JIT_BASE_NAMESPACE = 'angular:jit'; +/** + * A string value representing the namespace for Angular JIT mode related imports for + * Component styles. This namespace is used for both inline (`styles`) and external + * (`styleUrls`) styles. + */ +exports.JIT_STYLE_NAMESPACE = `${JIT_BASE_NAMESPACE}:style`; +/** + * A string value representing the namespace for Angular JIT mode related imports for + * Component templates. This namespace is currently only used for external (`templateUrl`) + * templates. + */ +exports.JIT_TEMPLATE_NAMESPACE = `${JIT_BASE_NAMESPACE}:template`; +/** + * A regular expression that can be used to match a Angular JIT mode namespace URI. + * It contains capture groups for the type (template/style), origin (file/inline), and specifier. + * The {@link parseJitUri} function can be used to parse and return an object representation of a JIT URI. + */ +exports.JIT_NAMESPACE_REGEXP = new RegExp(`^${JIT_BASE_NAMESPACE}:(template|style):(file|inline);(.*)$`); +/** + * Generates an Angular JIT mode namespace URI for a given file. + * @param file The path of the file to be included. + * @param type The type of the file (`style` or `template`). + * @returns A string containing the full JIT namespace URI. + */ +function generateJitFileUri(file, type) { + return `${JIT_BASE_NAMESPACE}:${type}:file;${file}`; +} +exports.generateJitFileUri = generateJitFileUri; +/** + * Generates an Angular JIT mode namespace URI for a given inline style or template. + * The provided content is base64 encoded and included in the URI. + * @param data The content to encode within the URI. + * @param type The type of the content (`style` or `template`). + * @returns A string containing the full JIT namespace URI. + */ +function generateJitInlineUri(data, type) { + return `${JIT_BASE_NAMESPACE}:${type}:inline;${Buffer.from(data).toString('base64')}`; +} +exports.generateJitInlineUri = generateJitInlineUri; +/** + * Parses a string containing a JIT namespace URI. + * JIT namespace URIs are used to encode the information for an Angular component's stylesheets + * and templates when compiled in JIT mode. + * @param uri The URI to parse into its underlying components. + * @returns An object containing the namespace, type, origin, and specifier of the URI; + * `undefined` if not a JIT namespace URI. + */ +function parseJitUri(uri) { + const matches = exports.JIT_NAMESPACE_REGEXP.exec(uri); + if (!matches) { + return undefined; + } + return { + namespace: `${JIT_BASE_NAMESPACE}:${matches[1]}`, + type: matches[1], + origin: matches[2], + specifier: matches[3], + }; +} +exports.parseJitUri = parseJitUri; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXJpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvYW5ndWxhcl9kZXZraXQvYnVpbGRfYW5ndWxhci9zcmMvYnVpbGRlcnMvYnJvd3Nlci1lc2J1aWxkL2FuZ3VsYXIvdXJpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7O0dBTUc7OztBQUVIOztHQUVHO0FBQ0gsTUFBTSxrQkFBa0IsR0FBRyxhQUFhLENBQUM7QUFFekM7Ozs7R0FJRztBQUNVLFFBQUEsbUJBQW1CLEdBQUcsR0FBRyxrQkFBa0IsUUFBaUIsQ0FBQztBQUUxRTs7OztHQUlHO0FBQ1UsUUFBQSxzQkFBc0IsR0FBRyxHQUFHLGtCQUFrQixXQUFvQixDQUFDO0FBRWhGOzs7O0dBSUc7QUFDVSxRQUFBLG9CQUFvQixHQUFHLElBQUksTUFBTSxDQUM1QyxJQUFJLGtCQUFrQix1Q0FBdUMsQ0FDOUQsQ0FBQztBQUVGOzs7OztHQUtHO0FBQ0gsU0FBZ0Isa0JBQWtCLENBQUMsSUFBWSxFQUFFLElBQTBCO0lBQ3pFLE9BQU8sR0FBRyxrQkFBa0IsSUFBSSxJQUFJLFNBQVMsSUFBSSxFQUFFLENBQUM7QUFDdEQsQ0FBQztBQUZELGdEQUVDO0FBRUQ7Ozs7OztHQU1HO0FBQ0gsU0FBZ0Isb0JBQW9CLENBQUMsSUFBeUIsRUFBRSxJQUEwQjtJQUN4RixPQUFPLEdBQUcsa0JBQWtCLElBQUksSUFBSSxXQUFXLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxFQUFFLENBQUM7QUFDeEYsQ0FBQztBQUZELG9EQUVDO0FBRUQ7Ozs7Ozs7R0FPRztBQUNILFNBQWdCLFdBQVcsQ0FBQyxHQUFXO0lBQ3JDLE1BQU0sT0FBTyxHQUFHLDRCQUFvQixDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUMvQyxJQUFJLENBQUMsT0FBTyxFQUFFO1FBQ1osT0FBTyxTQUFTLENBQUM7S0FDbEI7SUFFRCxPQUFPO1FBQ0wsU0FBUyxFQUFFLEdBQUcsa0JBQWtCLElBQUksT0FBTyxDQUFDLENBQUMsQ0FBQyxFQUFFO1FBQ2hELElBQUksRUFBRSxPQUFPLENBQUMsQ0FBQyxDQUF5QjtRQUN4QyxNQUFNLEVBQUUsT0FBTyxDQUFDLENBQUMsQ0FBc0I7UUFDdkMsU0FBUyxFQUFFLE9BQU8sQ0FBQyxDQUFDLENBQUM7S0FDdEIsQ0FBQztBQUNKLENBQUM7QUFaRCxrQ0FZQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG4vKipcbiAqIEEgc3RyaW5nIHZhbHVlIHJlcHJlc2VudGluZyB0aGUgYmFzZSBuYW1lc3BhY2UgZm9yIEFuZ3VsYXIgSklUIG1vZGUgcmVsYXRlZCBpbXBvcnRzLlxuICovXG5jb25zdCBKSVRfQkFTRV9OQU1FU1BBQ0UgPSAnYW5ndWxhcjpqaXQnO1xuXG4vKipcbiAqIEEgc3RyaW5nIHZhbHVlIHJlcHJlc2VudGluZyB0aGUgbmFtZXNwYWNlIGZvciBBbmd1bGFyIEpJVCBtb2RlIHJlbGF0ZWQgaW1wb3J0cyBmb3JcbiAqIENvbXBvbmVudCBzdHlsZXMuIFRoaXMgbmFtZXNwYWNlIGlzIHVzZWQgZm9yIGJvdGggaW5saW5lIChgc3R5bGVzYCkgYW5kIGV4dGVybmFsXG4gKiAoYHN0eWxlVXJsc2ApIHN0eWxlcy5cbiAqL1xuZXhwb3J0IGNvbnN0IEpJVF9TVFlMRV9OQU1FU1BBQ0UgPSBgJHtKSVRfQkFTRV9OQU1FU1BBQ0V9OnN0eWxlYCBhcyBjb25zdDtcblxuLyoqXG4gKiBBIHN0cmluZyB2YWx1ZSByZXByZXNlbnRpbmcgdGhlIG5hbWVzcGFjZSBmb3IgQW5ndWxhciBKSVQgbW9kZSByZWxhdGVkIGltcG9ydHMgZm9yXG4gKiBDb21wb25lbnQgdGVtcGxhdGVzLiBUaGlzIG5hbWVzcGFjZSBpcyBjdXJyZW50bHkgb25seSB1c2VkIGZvciBleHRlcm5hbCAoYHRlbXBsYXRlVXJsYClcbiAqIHRlbXBsYXRlcy5cbiAqL1xuZXhwb3J0IGNvbnN0IEpJVF9URU1QTEFURV9OQU1FU1BBQ0UgPSBgJHtKSVRfQkFTRV9OQU1FU1BBQ0V9OnRlbXBsYXRlYCBhcyBjb25zdDtcblxuLyoqXG4gKiBBIHJlZ3VsYXIgZXhwcmVzc2lvbiB0aGF0IGNhbiBiZSB1c2VkIHRvIG1hdGNoIGEgQW5ndWxhciBKSVQgbW9kZSBuYW1lc3BhY2UgVVJJLlxuICogSXQgY29udGFpbnMgY2FwdHVyZSBncm91cHMgZm9yIHRoZSB0eXBlICh0ZW1wbGF0ZS9zdHlsZSksIG9yaWdpbiAoZmlsZS9pbmxpbmUpLCBhbmQgc3BlY2lmaWVyLlxuICogVGhlIHtAbGluayBwYXJzZUppdFVyaX0gZnVuY3Rpb24gY2FuIGJlIHVzZWQgdG8gcGFyc2UgYW5kIHJldHVybiBhbiBvYmplY3QgcmVwcmVzZW50YXRpb24gb2YgYSBKSVQgVVJJLlxuICovXG5leHBvcnQgY29uc3QgSklUX05BTUVTUEFDRV9SRUdFWFAgPSBuZXcgUmVnRXhwKFxuICBgXiR7SklUX0JBU0VfTkFNRVNQQUNFfToodGVtcGxhdGV8c3R5bGUpOihmaWxlfGlubGluZSk7KC4qKSRgLFxuKTtcblxuLyoqXG4gKiBHZW5lcmF0ZXMgYW4gQW5ndWxhciBKSVQgbW9kZSBuYW1lc3BhY2UgVVJJIGZvciBhIGdpdmVuIGZpbGUuXG4gKiBAcGFyYW0gZmlsZSBUaGUgcGF0aCBvZiB0aGUgZmlsZSB0byBiZSBpbmNsdWRlZC5cbiAqIEBwYXJhbSB0eXBlIFRoZSB0eXBlIG9mIHRoZSBmaWxlIChgc3R5bGVgIG9yIGB0ZW1wbGF0ZWApLlxuICogQHJldHVybnMgQSBzdHJpbmcgY29udGFpbmluZyB0aGUgZnVsbCBKSVQgbmFtZXNwYWNlIFVSSS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdlbmVyYXRlSml0RmlsZVVyaShmaWxlOiBzdHJpbmcsIHR5cGU6ICdzdHlsZScgfCAndGVtcGxhdGUnKSB7XG4gIHJldHVybiBgJHtKSVRfQkFTRV9OQU1FU1BBQ0V9OiR7dHlwZX06ZmlsZTske2ZpbGV9YDtcbn1cblxuLyoqXG4gKiBHZW5lcmF0ZXMgYW4gQW5ndWxhciBKSVQgbW9kZSBuYW1lc3BhY2UgVVJJIGZvciBhIGdpdmVuIGlubGluZSBzdHlsZSBvciB0ZW1wbGF0ZS5cbiAqIFRoZSBwcm92aWRlZCBjb250ZW50IGlzIGJhc2U2NCBlbmNvZGVkIGFuZCBpbmNsdWRlZCBpbiB0aGUgVVJJLlxuICogQHBhcmFtIGRhdGEgVGhlIGNvbnRlbnQgdG8gZW5jb2RlIHdpdGhpbiB0aGUgVVJJLlxuICogQHBhcmFtIHR5cGUgVGhlIHR5cGUgb2YgdGhlIGNvbnRlbnQgKGBzdHlsZWAgb3IgYHRlbXBsYXRlYCkuXG4gKiBAcmV0dXJucyBBIHN0cmluZyBjb250YWluaW5nIHRoZSBmdWxsIEpJVCBuYW1lc3BhY2UgVVJJLlxuICovXG5leHBvcnQgZnVuY3Rpb24gZ2VuZXJhdGVKaXRJbmxpbmVVcmkoZGF0YTogc3RyaW5nIHwgVWludDhBcnJheSwgdHlwZTogJ3N0eWxlJyB8ICd0ZW1wbGF0ZScpIHtcbiAgcmV0dXJuIGAke0pJVF9CQVNFX05BTUVTUEFDRX06JHt0eXBlfTppbmxpbmU7JHtCdWZmZXIuZnJvbShkYXRhKS50b1N0cmluZygnYmFzZTY0Jyl9YDtcbn1cblxuLyoqXG4gKiBQYXJzZXMgYSBzdHJpbmcgY29udGFpbmluZyBhIEpJVCBuYW1lc3BhY2UgVVJJLlxuICogSklUIG5hbWVzcGFjZSBVUklzIGFyZSB1c2VkIHRvIGVuY29kZSB0aGUgaW5mb3JtYXRpb24gZm9yIGFuIEFuZ3VsYXIgY29tcG9uZW50J3Mgc3R5bGVzaGVldHNcbiAqIGFuZCB0ZW1wbGF0ZXMgd2hlbiBjb21waWxlZCBpbiBKSVQgbW9kZS5cbiAqIEBwYXJhbSB1cmkgVGhlIFVSSSB0byBwYXJzZSBpbnRvIGl0cyB1bmRlcmx5aW5nIGNvbXBvbmVudHMuXG4gKiBAcmV0dXJucyBBbiBvYmplY3QgY29udGFpbmluZyB0aGUgbmFtZXNwYWNlLCB0eXBlLCBvcmlnaW4sIGFuZCBzcGVjaWZpZXIgb2YgdGhlIFVSSTtcbiAqIGB1bmRlZmluZWRgIGlmIG5vdCBhIEpJVCBuYW1lc3BhY2UgVVJJLlxuICovXG5leHBvcnQgZnVuY3Rpb24gcGFyc2VKaXRVcmkodXJpOiBzdHJpbmcpIHtcbiAgY29uc3QgbWF0Y2hlcyA9IEpJVF9OQU1FU1BBQ0VfUkVHRVhQLmV4ZWModXJpKTtcbiAgaWYgKCFtYXRjaGVzKSB7XG4gICAgcmV0dXJuIHVuZGVmaW5lZDtcbiAgfVxuXG4gIHJldHVybiB7XG4gICAgbmFtZXNwYWNlOiBgJHtKSVRfQkFTRV9OQU1FU1BBQ0V9OiR7bWF0Y2hlc1sxXX1gLFxuICAgIHR5cGU6IG1hdGNoZXNbMV0gYXMgJ3N0eWxlJyB8ICd0ZW1wbGF0ZScsXG4gICAgb3JpZ2luOiBtYXRjaGVzWzJdIGFzICdmaWxlJyB8ICdpbmxpbmUnLFxuICAgIHNwZWNpZmllcjogbWF0Y2hlc1szXSxcbiAgfTtcbn1cbiJdfQ== \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/builder-status-warnings.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/builder-status-warnings.d.ts new file mode 100644 index 00000000..109f739a --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/builder-status-warnings.d.ts @@ -0,0 +1,10 @@ +/** + * @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 { BrowserEsbuildOptions } from './options'; +export declare function logBuilderStatusWarnings(options: BrowserEsbuildOptions, context: BuilderContext): void; diff --git a/artifacts/build-angular/src/builders/browser-esbuild/builder-status-warnings.js b/artifacts/build-angular/src/builders/browser-esbuild/builder-status-warnings.js new file mode 100644 index 00000000..b36d521c --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/builder-status-warnings.js @@ -0,0 +1,54 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.logBuilderStatusWarnings = void 0; +const UNSUPPORTED_OPTIONS = [ + 'budgets', + // * i18n support + 'localize', + // The following two have no effect when localize is not enabled + // 'i18nDuplicateTranslation', + // 'i18nMissingTranslation', + // * Deprecated + 'deployUrl', + // * Always enabled with esbuild + // 'commonChunk', + // * Unused by builder and will be removed in a future release + 'namedChunks', + 'vendorChunk', + // * Currently unsupported by esbuild + 'webWorkerTsConfig', +]; +function logBuilderStatusWarnings(options, context) { + context.logger.warn(`The esbuild-based browser application builder ('browser-esbuild') is currently in developer preview` + + ' and is not yet recommended for production use.' + + ' For additional information, please see https://angular.io/guide/esbuild'); + // Validate supported options + for (const unsupportedOption of UNSUPPORTED_OPTIONS) { + const value = options[unsupportedOption]; + if (value === undefined || value === false) { + continue; + } + if (Array.isArray(value) && value.length === 0) { + continue; + } + if (typeof value === 'object' && Object.keys(value).length === 0) { + continue; + } + if (unsupportedOption === 'namedChunks' || + unsupportedOption === 'vendorChunk' || + unsupportedOption === 'deployUrl') { + context.logger.warn(`The '${unsupportedOption}' option is not used by this builder and will be ignored.`); + continue; + } + context.logger.warn(`The '${unsupportedOption}' option is not yet supported by this builder.`); + } +} +exports.logBuilderStatusWarnings = logBuilderStatusWarnings; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/commonjs-checker.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/commonjs-checker.d.ts new file mode 100644 index 00000000..afbc9d3a --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/commonjs-checker.d.ts @@ -0,0 +1,28 @@ +/** + * @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 type { Metafile, PartialMessage } from 'esbuild'; +/** + * Checks the input files of a build to determine if any of the files included + * in the build are not ESM. ESM files can be tree-shaken and otherwise optimized + * in ways that CommonJS and other module formats cannot. The esbuild metafile + * information is used as the basis for the analysis as it contains information + * for each input file including its respective format. + * + * If any allowed dependencies are provided via the `allowedCommonJsDependencies` + * parameter, both the direct import and any deep imports will be ignored and no + * diagnostic will be generated. + * + * If a module has been issued a diagnostic message, then all descendant modules + * will not be checked. This prevents a potential massive amount of inactionable + * messages since the initial module import is the cause of the problem. + * + * @param metafile An esbuild metafile object to check. + * @param allowedCommonJsDependencies An optional list of allowed dependencies. + * @returns Zero or more diagnostic messages for any non-ESM modules. + */ +export declare function checkCommonJSModules(metafile: Metafile, allowedCommonJsDependencies?: string[]): PartialMessage[]; diff --git a/artifacts/build-angular/src/builders/browser-esbuild/commonjs-checker.js b/artifacts/build-angular/src/builders/browser-esbuild/commonjs-checker.js new file mode 100644 index 00000000..bb0ab18b --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/commonjs-checker.js @@ -0,0 +1,125 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.checkCommonJSModules = void 0; +/** + * Checks the input files of a build to determine if any of the files included + * in the build are not ESM. ESM files can be tree-shaken and otherwise optimized + * in ways that CommonJS and other module formats cannot. The esbuild metafile + * information is used as the basis for the analysis as it contains information + * for each input file including its respective format. + * + * If any allowed dependencies are provided via the `allowedCommonJsDependencies` + * parameter, both the direct import and any deep imports will be ignored and no + * diagnostic will be generated. + * + * If a module has been issued a diagnostic message, then all descendant modules + * will not be checked. This prevents a potential massive amount of inactionable + * messages since the initial module import is the cause of the problem. + * + * @param metafile An esbuild metafile object to check. + * @param allowedCommonJsDependencies An optional list of allowed dependencies. + * @returns Zero or more diagnostic messages for any non-ESM modules. + */ +function checkCommonJSModules(metafile, allowedCommonJsDependencies) { + const messages = []; + const allowedRequests = new Set(allowedCommonJsDependencies); + // Ignore Angular locale definitions which are currently UMD + allowedRequests.add('@angular/common/locales'); + // Ignore zone.js due to it currently being built with a UMD like structure. + // Once the build output is updated to be fully ESM, this can be removed. + allowedRequests.add('zone.js'); + // Find all entry points that contain code (JS/TS) + const files = []; + for (const { entryPoint } of Object.values(metafile.outputs)) { + if (!entryPoint) { + continue; + } + if (!isPathCode(entryPoint)) { + continue; + } + files.push(entryPoint); + } + // Track seen files so they are only analyzed once. + // Bundler runtime code is also ignored since it cannot be actionable. + const seenFiles = new Set(['']); + // Analyze the files present by walking the import graph + let currentFile; + while ((currentFile = files.shift())) { + const input = metafile.inputs[currentFile]; + for (const imported of input.imports) { + // Ignore imports that were already seen or not originally in the code (bundler injected) + if (!imported.original || seenFiles.has(imported.path)) { + continue; + } + seenFiles.add(imported.path); + // Only check actual code files + if (!isPathCode(imported.path)) { + continue; + } + // Check if the import is ESM format and issue a diagnostic if the file is not allowed + if (metafile.inputs[imported.path].format !== 'esm') { + const request = imported.original; + let notAllowed = true; + if (allowedRequests.has(request)) { + notAllowed = false; + } + else { + // Check for deep imports of allowed requests + for (const allowed of allowedRequests) { + if (request.startsWith(allowed + '/')) { + notAllowed = false; + break; + } + } + } + if (notAllowed) { + // Issue a diagnostic message and skip all descendants since they are also most + // likely not ESM but solved by addressing this import. + messages.push(createCommonJSModuleError(request, currentFile)); + continue; + } + } + // Add the path so that its imports can be checked + files.push(imported.path); + } + } + return messages; +} +exports.checkCommonJSModules = checkCommonJSModules; +/** + * Determines if a file path has an extension that is a JavaScript or TypeScript + * code file. + * + * @param name A path to check for code file extensions. + * @returns True, if a code file path; false, otherwise. + */ +function isPathCode(name) { + return /\.[cm]?[jt]sx?$/.test(name); +} +/** + * Creates an esbuild diagnostic message for a given non-ESM module request. + * + * @param request The requested non-ESM module name. + * @param importer The path of the file containing the import. + * @returns A message representing the diagnostic. + */ +function createCommonJSModuleError(request, importer) { + const error = { + text: `Module '${request}' used by '${importer}' is not ESM`, + notes: [ + { + text: 'CommonJS or AMD dependencies can cause optimization bailouts.\n' + + 'For more information see: https://angular.io/guide/build#configuring-commonjs-dependencies', + }, + ], + }; + return error; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"commonjs-checker.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/commonjs-checker.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 type { Metafile, PartialMessage } from 'esbuild';\n\n/**\n * Checks the input files of a build to determine if any of the files included\n * in the build are not ESM. ESM files can be tree-shaken and otherwise optimized\n * in ways that CommonJS and other module formats cannot. The esbuild metafile\n * information is used as the basis for the analysis as it contains information\n * for each input file including its respective format.\n *\n * If any allowed dependencies are provided via the `allowedCommonJsDependencies`\n * parameter, both the direct import and any deep imports will be ignored and no\n * diagnostic will be generated.\n *\n * If a module has been issued a diagnostic message, then all descendant modules\n * will not be checked. This prevents a potential massive amount of inactionable\n * messages since the initial module import is the cause of the problem.\n *\n * @param metafile An esbuild metafile object to check.\n * @param allowedCommonJsDependencies An optional list of allowed dependencies.\n * @returns Zero or more diagnostic messages for any non-ESM modules.\n */\nexport function checkCommonJSModules(\n  metafile: Metafile,\n  allowedCommonJsDependencies?: string[],\n): PartialMessage[] {\n  const messages: PartialMessage[] = [];\n  const allowedRequests = new Set(allowedCommonJsDependencies);\n\n  // Ignore Angular locale definitions which are currently UMD\n  allowedRequests.add('@angular/common/locales');\n\n  // Ignore zone.js due to it currently being built with a UMD like structure.\n  // Once the build output is updated to be fully ESM, this can be removed.\n  allowedRequests.add('zone.js');\n\n  // Find all entry points that contain code (JS/TS)\n  const files: string[] = [];\n  for (const { entryPoint } of Object.values(metafile.outputs)) {\n    if (!entryPoint) {\n      continue;\n    }\n    if (!isPathCode(entryPoint)) {\n      continue;\n    }\n\n    files.push(entryPoint);\n  }\n\n  // Track seen files so they are only analyzed once.\n  // Bundler runtime code is also ignored since it cannot be actionable.\n  const seenFiles = new Set<string>(['<runtime>']);\n\n  // Analyze the files present by walking the import graph\n  let currentFile: string | undefined;\n  while ((currentFile = files.shift())) {\n    const input = metafile.inputs[currentFile];\n\n    for (const imported of input.imports) {\n      // Ignore imports that were already seen or not originally in the code (bundler injected)\n      if (!imported.original || seenFiles.has(imported.path)) {\n        continue;\n      }\n      seenFiles.add(imported.path);\n\n      // Only check actual code files\n      if (!isPathCode(imported.path)) {\n        continue;\n      }\n\n      // Check if the import is ESM format and issue a diagnostic if the file is not allowed\n      if (metafile.inputs[imported.path].format !== 'esm') {\n        const request = imported.original;\n\n        let notAllowed = true;\n        if (allowedRequests.has(request)) {\n          notAllowed = false;\n        } else {\n          // Check for deep imports of allowed requests\n          for (const allowed of allowedRequests) {\n            if (request.startsWith(allowed + '/')) {\n              notAllowed = false;\n              break;\n            }\n          }\n        }\n\n        if (notAllowed) {\n          // Issue a diagnostic message and skip all descendants since they are also most\n          // likely not ESM but solved by addressing this import.\n          messages.push(createCommonJSModuleError(request, currentFile));\n          continue;\n        }\n      }\n\n      // Add the path so that its imports can be checked\n      files.push(imported.path);\n    }\n  }\n\n  return messages;\n}\n\n/**\n * Determines if a file path has an extension that is a JavaScript or TypeScript\n * code file.\n *\n * @param name A path to check for code file extensions.\n * @returns True, if a code file path; false, otherwise.\n */\nfunction isPathCode(name: string): boolean {\n  return /\\.[cm]?[jt]sx?$/.test(name);\n}\n\n/**\n * Creates an esbuild diagnostic message for a given non-ESM module request.\n *\n * @param request The requested non-ESM module name.\n * @param importer The path of the file containing the import.\n * @returns A message representing the diagnostic.\n */\nfunction createCommonJSModuleError(request: string, importer: string): PartialMessage {\n  const error = {\n    text: `Module '${request}' used by '${importer}' is not ESM`,\n    notes: [\n      {\n        text:\n          'CommonJS or AMD dependencies can cause optimization bailouts.\\n' +\n          'For more information see: https://angular.io/guide/build#configuring-commonjs-dependencies',\n      },\n    ],\n  };\n\n  return error;\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/esbuild.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/esbuild.d.ts new file mode 100644 index 00000000..3efaf261 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/esbuild.d.ts @@ -0,0 +1,53 @@ +/** + * @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 { BuildFailure, BuildOptions, Message, Metafile, OutputFile, PartialMessage } from 'esbuild'; +import { FileInfo } from '../../utils/index-file/augment-index-html'; +export type BundleContextResult = { + errors: Message[]; + warnings: Message[]; +} | { + errors: undefined; + warnings: Message[]; + metafile: Metafile; + outputFiles: OutputFile[]; + initialFiles: FileInfo[]; +}; +/** + * Determines if an unknown value is an esbuild BuildFailure error object thrown by esbuild. + * @param value A potential esbuild BuildFailure error object. + * @returns `true` if the object is determined to be a BuildFailure object; otherwise, `false`. + */ +export declare function isEsBuildFailure(value: unknown): value is BuildFailure; +export declare class BundlerContext { + #private; + private workspaceRoot; + private incremental; + constructor(workspaceRoot: string, incremental: boolean, options: BuildOptions); + static bundleAll(contexts: Iterable): Promise; + /** + * Executes the esbuild build function and normalizes the build result in the event of a + * build failure that results in no output being generated. + * All builds use the `write` option with a value of `false` to allow for the output files + * build result array to be populated. + * + * @returns If output files are generated, the full esbuild BuildResult; if not, the + * warnings and errors for the attempted build. + */ + bundle(): Promise; + /** + * Disposes incremental build resources present in the context. + * + * @returns A promise that resolves when disposal is complete. + */ + dispose(): Promise; +} +export declare function logMessages(context: BuilderContext, { errors, warnings }: { + errors?: PartialMessage[]; + warnings?: PartialMessage[]; +}): Promise; diff --git a/artifacts/build-angular/src/builders/browser-esbuild/esbuild.js b/artifacts/build-angular/src/builders/browser-esbuild/esbuild.js new file mode 100644 index 00000000..b68134b4 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/esbuild.js @@ -0,0 +1,178 @@ +"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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) { + if (kind === "m") throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; +}; +var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +}; +var _BundlerContext_esbuildContext, _BundlerContext_esbuildOptions; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.logMessages = exports.BundlerContext = exports.isEsBuildFailure = void 0; +const esbuild_1 = require("esbuild"); +const node_path_1 = require("node:path"); +/** + * Determines if an unknown value is an esbuild BuildFailure error object thrown by esbuild. + * @param value A potential esbuild BuildFailure error object. + * @returns `true` if the object is determined to be a BuildFailure object; otherwise, `false`. + */ +function isEsBuildFailure(value) { + return !!value && typeof value === 'object' && 'errors' in value && 'warnings' in value; +} +exports.isEsBuildFailure = isEsBuildFailure; +class BundlerContext { + constructor(workspaceRoot, incremental, options) { + this.workspaceRoot = workspaceRoot; + this.incremental = incremental; + _BundlerContext_esbuildContext.set(this, void 0); + _BundlerContext_esbuildOptions.set(this, void 0); + __classPrivateFieldSet(this, _BundlerContext_esbuildOptions, { + ...options, + metafile: true, + write: false, + }, "f"); + } + static async bundleAll(contexts) { + const individualResults = await Promise.all([...contexts].map((context) => context.bundle())); + // Return directly if only one result + if (individualResults.length === 1) { + return individualResults[0]; + } + let errors; + const warnings = []; + const metafile = { inputs: {}, outputs: {} }; + const initialFiles = []; + const outputFiles = []; + for (const result of individualResults) { + warnings.push(...result.warnings); + if (result.errors) { + errors ?? (errors = []); + errors.push(...result.errors); + continue; + } + // Combine metafiles used for the stats option as well as bundle budgets and console output + if (result.metafile) { + metafile.inputs = { ...metafile.inputs, ...result.metafile.inputs }; + metafile.outputs = { ...metafile.outputs, ...result.metafile.outputs }; + } + initialFiles.push(...result.initialFiles); + outputFiles.push(...result.outputFiles); + } + if (errors !== undefined) { + return { errors, warnings }; + } + return { + errors, + warnings, + metafile, + initialFiles, + outputFiles, + }; + } + /** + * Executes the esbuild build function and normalizes the build result in the event of a + * build failure that results in no output being generated. + * All builds use the `write` option with a value of `false` to allow for the output files + * build result array to be populated. + * + * @returns If output files are generated, the full esbuild BuildResult; if not, the + * warnings and errors for the attempted build. + */ + async bundle() { + let result; + try { + if (__classPrivateFieldGet(this, _BundlerContext_esbuildContext, "f")) { + // Rebuild using the existing incremental build context + result = await __classPrivateFieldGet(this, _BundlerContext_esbuildContext, "f").rebuild(); + } + else if (this.incremental) { + // Create an incremental build context and perform the first build. + // Context creation does not perform a build. + __classPrivateFieldSet(this, _BundlerContext_esbuildContext, await (0, esbuild_1.context)(__classPrivateFieldGet(this, _BundlerContext_esbuildOptions, "f")), "f"); + result = await __classPrivateFieldGet(this, _BundlerContext_esbuildContext, "f").rebuild(); + } + else { + // For non-incremental builds, perform a single build + result = await (0, esbuild_1.build)(__classPrivateFieldGet(this, _BundlerContext_esbuildOptions, "f")); + } + } + catch (failure) { + // Build failures will throw an exception which contains errors/warnings + if (isEsBuildFailure(failure)) { + return failure; + } + else { + throw failure; + } + } + // Return if the build encountered any errors + if (result.errors.length) { + return { + errors: result.errors, + warnings: result.warnings, + }; + } + // Find all initial files + const initialFiles = []; + for (const outputFile of result.outputFiles) { + // Entries in the metafile are relative to the `absWorkingDir` option which is set to the workspaceRoot + const relativeFilePath = (0, node_path_1.relative)(this.workspaceRoot, outputFile.path); + const entryPoint = result.metafile?.outputs[relativeFilePath]?.entryPoint; + outputFile.path = relativeFilePath; + if (entryPoint) { + // The first part of the filename is the name of file (e.g., "polyfills" for "polyfills.7S5G3MDY.js") + const name = (0, node_path_1.basename)(outputFile.path).split('.', 1)[0]; + // Only entrypoints with an entry in the options are initial files. + // Dynamic imports also have an entryPoint value in the meta file. + if (__classPrivateFieldGet(this, _BundlerContext_esbuildOptions, "f").entryPoints?.[name]) { + // An entryPoint value indicates an initial file + initialFiles.push({ + file: outputFile.path, + name, + extension: (0, node_path_1.extname)(outputFile.path), + }); + } + } + } + // Return the successful build results + return { ...result, initialFiles, errors: undefined }; + } + /** + * Disposes incremental build resources present in the context. + * + * @returns A promise that resolves when disposal is complete. + */ + async dispose() { + try { + return __classPrivateFieldGet(this, _BundlerContext_esbuildContext, "f")?.dispose(); + } + finally { + __classPrivateFieldSet(this, _BundlerContext_esbuildContext, undefined, "f"); + } + } +} +exports.BundlerContext = BundlerContext; +_BundlerContext_esbuildContext = new WeakMap(), _BundlerContext_esbuildOptions = new WeakMap(); +async function logMessages(context, { errors, warnings }) { + if (warnings?.length) { + const warningMessages = await (0, esbuild_1.formatMessages)(warnings, { kind: 'warning', color: true }); + context.logger.warn(warningMessages.join('\n')); + } + if (errors?.length) { + const errorMessages = await (0, esbuild_1.formatMessages)(errors, { kind: 'error', color: true }); + context.logger.error(errorMessages.join('\n')); + } +} +exports.logMessages = logMessages; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"esbuild.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/esbuild.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 { BuilderContext } from '@angular-devkit/architect';\nimport {\n  BuildContext,\n  BuildFailure,\n  BuildOptions,\n  Message,\n  Metafile,\n  OutputFile,\n  PartialMessage,\n  build,\n  context,\n  formatMessages,\n} from 'esbuild';\nimport { basename, extname, relative } from 'node:path';\nimport { FileInfo } from '../../utils/index-file/augment-index-html';\n\nexport type BundleContextResult =\n  | { errors: Message[]; warnings: Message[] }\n  | {\n      errors: undefined;\n      warnings: Message[];\n      metafile: Metafile;\n      outputFiles: OutputFile[];\n      initialFiles: FileInfo[];\n    };\n\n/**\n * Determines if an unknown value is an esbuild BuildFailure error object thrown by esbuild.\n * @param value A potential esbuild BuildFailure error object.\n * @returns `true` if the object is determined to be a BuildFailure object; otherwise, `false`.\n */\nexport function isEsBuildFailure(value: unknown): value is BuildFailure {\n  return !!value && typeof value === 'object' && 'errors' in value && 'warnings' in value;\n}\n\nexport class BundlerContext {\n  #esbuildContext?: BuildContext<{ metafile: true; write: false }>;\n  #esbuildOptions: BuildOptions & { metafile: true; write: false };\n\n  constructor(private workspaceRoot: string, private incremental: boolean, options: BuildOptions) {\n    this.#esbuildOptions = {\n      ...options,\n      metafile: true,\n      write: false,\n    };\n  }\n\n  static async bundleAll(contexts: Iterable<BundlerContext>): Promise<BundleContextResult> {\n    const individualResults = await Promise.all([...contexts].map((context) => context.bundle()));\n\n    // Return directly if only one result\n    if (individualResults.length === 1) {\n      return individualResults[0];\n    }\n\n    let errors: Message[] | undefined;\n    const warnings: Message[] = [];\n    const metafile: Metafile = { inputs: {}, outputs: {} };\n    const initialFiles = [];\n    const outputFiles = [];\n    for (const result of individualResults) {\n      warnings.push(...result.warnings);\n      if (result.errors) {\n        errors ??= [];\n        errors.push(...result.errors);\n        continue;\n      }\n\n      // Combine metafiles used for the stats option as well as bundle budgets and console output\n      if (result.metafile) {\n        metafile.inputs = { ...metafile.inputs, ...result.metafile.inputs };\n        metafile.outputs = { ...metafile.outputs, ...result.metafile.outputs };\n      }\n\n      initialFiles.push(...result.initialFiles);\n      outputFiles.push(...result.outputFiles);\n    }\n\n    if (errors !== undefined) {\n      return { errors, warnings };\n    }\n\n    return {\n      errors,\n      warnings,\n      metafile,\n      initialFiles,\n      outputFiles,\n    };\n  }\n\n  /**\n   * Executes the esbuild build function and normalizes the build result in the event of a\n   * build failure that results in no output being generated.\n   * All builds use the `write` option with a value of `false` to allow for the output files\n   * build result array to be populated.\n   *\n   * @returns If output files are generated, the full esbuild BuildResult; if not, the\n   * warnings and errors for the attempted build.\n   */\n  async bundle(): Promise<BundleContextResult> {\n    let result;\n    try {\n      if (this.#esbuildContext) {\n        // Rebuild using the existing incremental build context\n        result = await this.#esbuildContext.rebuild();\n      } else if (this.incremental) {\n        // Create an incremental build context and perform the first build.\n        // Context creation does not perform a build.\n        this.#esbuildContext = await context(this.#esbuildOptions);\n        result = await this.#esbuildContext.rebuild();\n      } else {\n        // For non-incremental builds, perform a single build\n        result = await build(this.#esbuildOptions);\n      }\n    } catch (failure) {\n      // Build failures will throw an exception which contains errors/warnings\n      if (isEsBuildFailure(failure)) {\n        return failure;\n      } else {\n        throw failure;\n      }\n    }\n\n    // Return if the build encountered any errors\n    if (result.errors.length) {\n      return {\n        errors: result.errors,\n        warnings: result.warnings,\n      };\n    }\n\n    // Find all initial files\n    const initialFiles: FileInfo[] = [];\n    for (const outputFile of result.outputFiles) {\n      // Entries in the metafile are relative to the `absWorkingDir` option which is set to the workspaceRoot\n      const relativeFilePath = relative(this.workspaceRoot, outputFile.path);\n      const entryPoint = result.metafile?.outputs[relativeFilePath]?.entryPoint;\n\n      outputFile.path = relativeFilePath;\n\n      if (entryPoint) {\n        // The first part of the filename is the name of file (e.g., \"polyfills\" for \"polyfills.7S5G3MDY.js\")\n        const name = basename(outputFile.path).split('.', 1)[0];\n\n        // Only entrypoints with an entry in the options are initial files.\n        // Dynamic imports also have an entryPoint value in the meta file.\n        if ((this.#esbuildOptions.entryPoints as Record<string, string>)?.[name]) {\n          // An entryPoint value indicates an initial file\n          initialFiles.push({\n            file: outputFile.path,\n            name,\n            extension: extname(outputFile.path),\n          });\n        }\n      }\n    }\n\n    // Return the successful build results\n    return { ...result, initialFiles, errors: undefined };\n  }\n\n  /**\n   * Disposes incremental build resources present in the context.\n   *\n   * @returns A promise that resolves when disposal is complete.\n   */\n  async dispose(): Promise<void> {\n    try {\n      return this.#esbuildContext?.dispose();\n    } finally {\n      this.#esbuildContext = undefined;\n    }\n  }\n}\n\nexport async function logMessages(\n  context: BuilderContext,\n  { errors, warnings }: { errors?: PartialMessage[]; warnings?: PartialMessage[] },\n): Promise<void> {\n  if (warnings?.length) {\n    const warningMessages = await formatMessages(warnings, { kind: 'warning', color: true });\n    context.logger.warn(warningMessages.join('\\n'));\n  }\n\n  if (errors?.length) {\n    const errorMessages = await formatMessages(errors, { kind: 'error', color: true });\n    context.logger.error(errorMessages.join('\\n'));\n  }\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/global-scripts.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/global-scripts.d.ts new file mode 100644 index 00000000..067909ba --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/global-scripts.d.ts @@ -0,0 +1,16 @@ +/** + * @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 type { BuildOptions } from 'esbuild'; +import { NormalizedBrowserOptions } from './options'; +/** + * Create an esbuild 'build' options object for all global scripts defined in the user provied + * build options. + * @param options The builder's user-provider normalized options. + * @returns An esbuild BuildOptions object. + */ +export declare function createGlobalScriptsBundleOptions(options: NormalizedBrowserOptions, initial: boolean): BuildOptions | undefined; diff --git a/artifacts/build-angular/src/builders/browser-esbuild/global-scripts.js b/artifacts/build-angular/src/builders/browser-esbuild/global-scripts.js new file mode 100644 index 00000000..5b4fea45 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/global-scripts.js @@ -0,0 +1,136 @@ +"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; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createGlobalScriptsBundleOptions = void 0; +const magic_string_1 = __importStar(require("magic-string")); +const node_assert_1 = __importDefault(require("node:assert")); +const promises_1 = require("node:fs/promises"); +const sourcemap_ignorelist_plugin_1 = require("./sourcemap-ignorelist-plugin"); +/** + * Create an esbuild 'build' options object for all global scripts defined in the user provied + * build options. + * @param options The builder's user-provider normalized options. + * @returns An esbuild BuildOptions object. + */ +function createGlobalScriptsBundleOptions(options, initial) { + const { globalScripts, optimizationOptions, outputNames, preserveSymlinks, sourcemapOptions, workspaceRoot, } = options; + const namespace = 'angular:script/global'; + const entryPoints = {}; + let found = false; + for (const script of globalScripts) { + if (script.initial === initial) { + found = true; + entryPoints[script.name] = `${namespace}:${script.name}`; + } + } + // Skip if there are no entry points for the style loading type + if (found === false) { + return; + } + return { + absWorkingDir: workspaceRoot, + bundle: false, + splitting: false, + entryPoints, + entryNames: initial ? outputNames.bundles : '[name]', + assetNames: outputNames.media, + mainFields: ['script', 'browser', 'main'], + conditions: ['script'], + resolveExtensions: ['.mjs', '.js'], + logLevel: options.verbose ? 'debug' : 'silent', + metafile: true, + minify: optimizationOptions.scripts, + outdir: workspaceRoot, + sourcemap: sourcemapOptions.scripts && (sourcemapOptions.hidden ? 'external' : true), + write: false, + platform: 'neutral', + preserveSymlinks, + plugins: [ + (0, sourcemap_ignorelist_plugin_1.createSourcemapIngorelistPlugin)(), + { + name: 'angular-global-scripts', + setup(build) { + build.onResolve({ filter: /^angular:script\/global:/ }, (args) => { + if (args.kind !== 'entry-point') { + return null; + } + return { + // Add the `js` extension here so that esbuild generates an output file with the extension + path: args.path.slice(namespace.length + 1) + '.js', + namespace, + }; + }); + // All references within a global script should be considered external. This maintains the runtime + // behavior of the script as if it were added directly to a script element for referenced imports. + build.onResolve({ filter: /./, namespace }, ({ path }) => { + return { + path, + external: true, + }; + }); + build.onLoad({ filter: /./, namespace }, async (args) => { + const files = globalScripts.find(({ name }) => name === args.path.slice(0, -3))?.files; + (0, node_assert_1.default)(files, `Invalid operation: global scripts name not found [${args.path}]`); + // Global scripts are concatenated using magic-string instead of bundled via esbuild. + const bundleContent = new magic_string_1.Bundle(); + for (const filename of files) { + const resolveResult = await build.resolve(filename, { + kind: 'entry-point', + resolveDir: workspaceRoot, + }); + if (resolveResult.errors.length) { + // Remove resolution failure notes about marking as external since it doesn't apply + // to global scripts. + resolveResult.errors.forEach((error) => (error.notes = [])); + return { + errors: resolveResult.errors, + warnings: resolveResult.warnings, + }; + } + const fileContent = await (0, promises_1.readFile)(resolveResult.path, 'utf-8'); + bundleContent.addSource(new magic_string_1.default(fileContent, { filename })); + } + return { + contents: bundleContent.toString(), + loader: 'js', + }; + }); + }, + }, + ], + }; +} +exports.createGlobalScriptsBundleOptions = createGlobalScriptsBundleOptions; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"global-scripts.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/global-scripts.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 type { BuildOptions } from 'esbuild';\nimport MagicString, { Bundle } from 'magic-string';\nimport assert from 'node:assert';\nimport { readFile } from 'node:fs/promises';\nimport { NormalizedBrowserOptions } from './options';\nimport { createSourcemapIngorelistPlugin } from './sourcemap-ignorelist-plugin';\n\n/**\n * Create an esbuild 'build' options object for all global scripts defined in the user provied\n * build options.\n * @param options The builder's user-provider normalized options.\n * @returns An esbuild BuildOptions object.\n */\nexport function createGlobalScriptsBundleOptions(\n  options: NormalizedBrowserOptions,\n  initial: boolean,\n): BuildOptions | undefined {\n  const {\n    globalScripts,\n    optimizationOptions,\n    outputNames,\n    preserveSymlinks,\n    sourcemapOptions,\n    workspaceRoot,\n  } = options;\n\n  const namespace = 'angular:script/global';\n  const entryPoints: Record<string, string> = {};\n  let found = false;\n  for (const script of globalScripts) {\n    if (script.initial === initial) {\n      found = true;\n      entryPoints[script.name] = `${namespace}:${script.name}`;\n    }\n  }\n\n  // Skip if there are no entry points for the style loading type\n  if (found === false) {\n    return;\n  }\n\n  return {\n    absWorkingDir: workspaceRoot,\n    bundle: false,\n    splitting: false,\n    entryPoints,\n    entryNames: initial ? outputNames.bundles : '[name]',\n    assetNames: outputNames.media,\n    mainFields: ['script', 'browser', 'main'],\n    conditions: ['script'],\n    resolveExtensions: ['.mjs', '.js'],\n    logLevel: options.verbose ? 'debug' : 'silent',\n    metafile: true,\n    minify: optimizationOptions.scripts,\n    outdir: workspaceRoot,\n    sourcemap: sourcemapOptions.scripts && (sourcemapOptions.hidden ? 'external' : true),\n    write: false,\n    platform: 'neutral',\n    preserveSymlinks,\n    plugins: [\n      createSourcemapIngorelistPlugin(),\n      {\n        name: 'angular-global-scripts',\n        setup(build) {\n          build.onResolve({ filter: /^angular:script\\/global:/ }, (args) => {\n            if (args.kind !== 'entry-point') {\n              return null;\n            }\n\n            return {\n              // Add the `js` extension here so that esbuild generates an output file with the extension\n              path: args.path.slice(namespace.length + 1) + '.js',\n              namespace,\n            };\n          });\n          // All references within a global script should be considered external. This maintains the runtime\n          // behavior of the script as if it were added directly to a script element for referenced imports.\n          build.onResolve({ filter: /./, namespace }, ({ path }) => {\n            return {\n              path,\n              external: true,\n            };\n          });\n          build.onLoad({ filter: /./, namespace }, async (args) => {\n            const files = globalScripts.find(({ name }) => name === args.path.slice(0, -3))?.files;\n            assert(files, `Invalid operation: global scripts name not found [${args.path}]`);\n\n            // Global scripts are concatenated using magic-string instead of bundled via esbuild.\n            const bundleContent = new Bundle();\n            for (const filename of files) {\n              const resolveResult = await build.resolve(filename, {\n                kind: 'entry-point',\n                resolveDir: workspaceRoot,\n              });\n\n              if (resolveResult.errors.length) {\n                // Remove resolution failure notes about marking as external since it doesn't apply\n                // to global scripts.\n                resolveResult.errors.forEach((error) => (error.notes = []));\n\n                return {\n                  errors: resolveResult.errors,\n                  warnings: resolveResult.warnings,\n                };\n              }\n\n              const fileContent = await readFile(resolveResult.path, 'utf-8');\n              bundleContent.addSource(new MagicString(fileContent, { filename }));\n            }\n\n            return {\n              contents: bundleContent.toString(),\n              loader: 'js',\n            };\n          });\n        },\n      },\n    ],\n  };\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/global-styles.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/global-styles.d.ts new file mode 100644 index 00000000..daf84ce8 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/global-styles.d.ts @@ -0,0 +1,11 @@ +/** + * @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 type { BuildOptions } from 'esbuild'; +import { LoadResultCache } from './load-result-cache'; +import { NormalizedBrowserOptions } from './options'; +export declare function createGlobalStylesBundleOptions(options: NormalizedBrowserOptions, target: string[], browsers: string[], initial: boolean, cache?: LoadResultCache): BuildOptions | undefined; diff --git a/artifacts/build-angular/src/builders/browser-esbuild/global-styles.js b/artifacts/build-angular/src/builders/browser-esbuild/global-styles.js new file mode 100644 index 00000000..ba92dc45 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/global-styles.js @@ -0,0 +1,76 @@ +"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 __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createGlobalStylesBundleOptions = void 0; +const node_assert_1 = __importDefault(require("node:assert")); +const bundle_options_1 = require("./stylesheets/bundle-options"); +function createGlobalStylesBundleOptions(options, target, browsers, initial, cache) { + const { workspaceRoot, optimizationOptions, sourcemapOptions, outputNames, globalStyles, preserveSymlinks, externalDependencies, stylePreprocessorOptions, tailwindConfiguration, } = options; + const namespace = 'angular:styles/global'; + const entryPoints = {}; + let found = false; + for (const style of globalStyles) { + if (style.initial === initial) { + found = true; + entryPoints[style.name] = `${namespace};${style.name}`; + } + } + // Skip if there are no entry points for the style loading type + if (found === false) { + return; + } + const buildOptions = (0, bundle_options_1.createStylesheetBundleOptions)({ + workspaceRoot, + optimization: !!optimizationOptions.styles.minify, + sourcemap: !!sourcemapOptions.styles, + preserveSymlinks, + target, + externalDependencies, + outputNames: initial + ? outputNames + : { + ...outputNames, + bundles: '[name]', + }, + includePaths: stylePreprocessorOptions?.includePaths, + browsers, + tailwindConfiguration, + }, cache); + buildOptions.legalComments = options.extractLicenses ? 'none' : 'eof'; + buildOptions.entryPoints = entryPoints; + buildOptions.plugins.unshift({ + name: 'angular-global-styles', + setup(build) { + build.onResolve({ filter: /^angular:styles\/global;/ }, (args) => { + if (args.kind !== 'entry-point') { + return null; + } + return { + path: args.path.split(';', 2)[1], + namespace, + }; + }); + build.onLoad({ filter: /./, namespace }, (args) => { + const files = globalStyles.find(({ name }) => name === args.path)?.files; + (0, node_assert_1.default)(files, `global style name should always be found [${args.path}]`); + return { + contents: files.map((file) => `@import '${file.replace(/\\/g, '/')}';`).join('\n'), + loader: 'css', + resolveDir: workspaceRoot, + }; + }); + }, + }); + return buildOptions; +} +exports.createGlobalStylesBundleOptions = createGlobalStylesBundleOptions; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/index.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/index.d.ts new file mode 100644 index 00000000..4eda4eaf --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/index.d.ts @@ -0,0 +1,45 @@ +/** + * @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 type { OutputFile } from 'esbuild'; +import { BrowserEsbuildOptions } from './options'; +import { Schema as BrowserBuilderOptions } from './schema'; +/** + * Main execution function for the esbuild-based application builder. + * The options are compatible with the Webpack-based builder. + * @param userOptions The browser builder options to use when setting up the application build + * @param context The Architect builder context object + * @returns An async iterable with the builder result output + */ +export declare function buildEsbuildBrowser(userOptions: BrowserBuilderOptions, context: BuilderContext, infrastructureSettings?: { + write?: boolean; +}): AsyncIterable; +/** + * Internal version of the main execution function for the esbuild-based application builder. + * Exposes some additional "private" options in addition to those exposed by the schema. + * @param userOptions The browser-esbuild builder options to use when setting up the application build + * @param context The Architect builder context object + * @returns An async iterable with the builder result output + */ +export declare function buildEsbuildBrowserInternal(userOptions: BrowserEsbuildOptions, context: BuilderContext, infrastructureSettings?: { + write?: boolean; +}): AsyncIterable; +declare const _default: import("../../../../architect/src/internal").Builder; +export default _default; diff --git a/artifacts/build-angular/src/builders/browser-esbuild/index.js b/artifacts/build-angular/src/builders/browser-esbuild/index.js new file mode 100644 index 00000000..6f76dd39 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/index.js @@ -0,0 +1,585 @@ +"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; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.buildEsbuildBrowserInternal = exports.buildEsbuildBrowser = void 0; +const architect_1 = require("@angular-devkit/architect"); +const node_fs_1 = require("node:fs"); +const promises_1 = __importDefault(require("node:fs/promises")); +const node_path_1 = __importDefault(require("node:path")); +const copy_assets_1 = require("../../utils/copy-assets"); +const error_1 = require("../../utils/error"); +const esbuild_targets_1 = require("../../utils/esbuild-targets"); +const index_html_generator_1 = require("../../utils/index-file/index-html-generator"); +const service_worker_1 = require("../../utils/service-worker"); +const spinner_1 = require("../../utils/spinner"); +const supported_browsers_1 = require("../../utils/supported-browsers"); +const stats_1 = require("../../webpack/utils/stats"); +const compiler_plugin_1 = require("./angular/compiler-plugin"); +const builder_status_warnings_1 = require("./builder-status-warnings"); +const commonjs_checker_1 = require("./commonjs-checker"); +const esbuild_1 = require("./esbuild"); +const global_scripts_1 = require("./global-scripts"); +const global_styles_1 = require("./global-styles"); +const license_extractor_1 = require("./license-extractor"); +const options_1 = require("./options"); +const sourcemap_ignorelist_plugin_1 = require("./sourcemap-ignorelist-plugin"); +const sass_plugin_1 = require("./stylesheets/sass-plugin"); +/** + * Represents the result of a single builder execute call. + */ +class ExecutionResult { + constructor(rebuildContexts, codeBundleCache) { + this.rebuildContexts = rebuildContexts; + this.codeBundleCache = codeBundleCache; + this.outputFiles = []; + this.assetFiles = []; + } + addOutputFile(path, content) { + this.outputFiles.push(createOutputFileFromText(path, content)); + } + get output() { + return { + success: this.outputFiles.length > 0, + }; + } + get outputWithFiles() { + return { + success: this.outputFiles.length > 0, + outputFiles: this.outputFiles, + assetFiles: this.assetFiles, + }; + } + createRebuildState(fileChanges) { + this.codeBundleCache?.invalidate([...fileChanges.modified, ...fileChanges.removed]); + return { + rebuildContexts: this.rebuildContexts, + codeBundleCache: this.codeBundleCache, + fileChanges, + }; + } + async dispose() { + await Promise.allSettled(this.rebuildContexts.map((context) => context.dispose())); + } +} +async function execute(options, context, rebuildState) { + const startTime = process.hrtime.bigint(); + const { projectRoot, workspaceRoot, optimizationOptions, assets, serviceWorkerOptions, indexHtmlOptions, } = options; + const browsers = (0, supported_browsers_1.getSupportedBrowsers)(projectRoot, context.logger); + const target = (0, esbuild_targets_1.transformSupportedBrowsersToTargets)(browsers); + // Reuse rebuild state or create new bundle contexts for code and global stylesheets + let bundlerContexts = rebuildState?.rebuildContexts; + const codeBundleCache = options.watch + ? rebuildState?.codeBundleCache ?? new compiler_plugin_1.SourceFileCache() + : undefined; + if (bundlerContexts === undefined) { + bundlerContexts = []; + // Application code + bundlerContexts.push(new esbuild_1.BundlerContext(workspaceRoot, !!options.watch, createCodeBundleOptions(options, target, browsers, codeBundleCache))); + // Global Stylesheets + if (options.globalStyles.length > 0) { + for (const initial of [true, false]) { + const bundleOptions = (0, global_styles_1.createGlobalStylesBundleOptions)(options, target, browsers, initial, codeBundleCache?.loadResultCache); + if (bundleOptions) { + bundlerContexts.push(new esbuild_1.BundlerContext(workspaceRoot, !!options.watch, bundleOptions)); + } + } + } + // Global Scripts + if (options.globalScripts.length > 0) { + for (const initial of [true, false]) { + const bundleOptions = (0, global_scripts_1.createGlobalScriptsBundleOptions)(options, initial); + if (bundleOptions) { + bundlerContexts.push(new esbuild_1.BundlerContext(workspaceRoot, !!options.watch, bundleOptions)); + } + } + } + } + const bundlingResult = await esbuild_1.BundlerContext.bundleAll(bundlerContexts); + // Log all warnings and errors generated during bundling + await (0, esbuild_1.logMessages)(context, bundlingResult); + const executionResult = new ExecutionResult(bundlerContexts, codeBundleCache); + // Return if the bundling has errors + if (bundlingResult.errors) { + return executionResult; + } + // Filter global stylesheet initial files. Currently all initial CSS files are from the global styles option. + if (options.globalStyles.length > 0) { + bundlingResult.initialFiles = bundlingResult.initialFiles.filter(({ file, name }) => !file.endsWith('.css') || + options.globalStyles.find((style) => style.name === name)?.initial); + } + const { metafile, initialFiles, outputFiles } = bundlingResult; + executionResult.outputFiles.push(...outputFiles); + // Check metafile for CommonJS module usage if optimizing scripts + if (optimizationOptions.scripts) { + const messages = (0, commonjs_checker_1.checkCommonJSModules)(metafile, options.allowedCommonJsDependencies); + await (0, esbuild_1.logMessages)(context, { warnings: messages }); + } + // Generate index HTML file + if (indexHtmlOptions) { + // Create an index HTML generator that reads from the in-memory output files + const indexHtmlGenerator = new index_html_generator_1.IndexHtmlGenerator({ + indexPath: indexHtmlOptions.input, + entrypoints: indexHtmlOptions.insertionOrder, + sri: options.subresourceIntegrity, + optimization: optimizationOptions, + crossOrigin: options.crossOrigin, + }); + /** Virtual output path to support reading in-memory files. */ + const virtualOutputPath = '/'; + indexHtmlGenerator.readAsset = async function (filePath) { + // Remove leading directory separator + const relativefilePath = node_path_1.default.relative(virtualOutputPath, filePath); + const file = executionResult.outputFiles.find((file) => file.path === relativefilePath); + if (file) { + return file.text; + } + throw new Error(`Output file does not exist: ${node_path_1.default}`); + }; + const { content, warnings, errors } = await indexHtmlGenerator.process({ + baseHref: options.baseHref, + lang: undefined, + outputPath: virtualOutputPath, + files: initialFiles, + }); + for (const error of errors) { + context.logger.error(error); + } + for (const warning of warnings) { + context.logger.warn(warning); + } + executionResult.addOutputFile(indexHtmlOptions.output, content); + } + // Copy assets + if (assets) { + // The webpack copy assets helper is used with no base paths defined. This prevents the helper + // from directly writing to disk. This should eventually be replaced with a more optimized helper. + executionResult.assetFiles.push(...(await (0, copy_assets_1.copyAssets)(assets, [], workspaceRoot))); + } + // Write metafile if stats option is enabled + if (options.stats) { + executionResult.addOutputFile('stats.json', JSON.stringify(metafile, null, 2)); + } + // Extract and write licenses for used packages + if (options.extractLicenses) { + executionResult.addOutputFile('3rdpartylicenses.txt', await (0, license_extractor_1.extractLicenses)(metafile, workspaceRoot)); + } + // Augment the application with service worker support + if (serviceWorkerOptions) { + try { + const serviceWorkerResult = await (0, service_worker_1.augmentAppWithServiceWorkerEsbuild)(workspaceRoot, serviceWorkerOptions, options.baseHref || '/', executionResult.outputFiles, executionResult.assetFiles); + executionResult.addOutputFile('ngsw.json', serviceWorkerResult.manifest); + executionResult.assetFiles.push(...serviceWorkerResult.assetFiles); + } + catch (error) { + context.logger.error(error instanceof Error ? error.message : `${error}`); + return executionResult; + } + } + logBuildStats(context, metafile, initialFiles); + const buildTime = Number(process.hrtime.bigint() - startTime) / 10 ** 9; + context.logger.info(`Application bundle generation complete. [${buildTime.toFixed(3)} seconds]`); + return executionResult; +} +async function writeResultFiles(outputFiles, assetFiles, outputPath) { + const directoryExists = new Set(); + await Promise.all(outputFiles.map(async (file) => { + // Ensure output subdirectories exist + const basePath = node_path_1.default.dirname(file.path); + if (basePath && !directoryExists.has(basePath)) { + await promises_1.default.mkdir(node_path_1.default.join(outputPath, basePath), { recursive: true }); + directoryExists.add(basePath); + } + // Write file contents + await promises_1.default.writeFile(node_path_1.default.join(outputPath, file.path), file.contents); + })); + if (assetFiles?.length) { + await Promise.all(assetFiles.map(async ({ source, destination }) => { + // Ensure output subdirectories exist + const basePath = node_path_1.default.dirname(destination); + if (basePath && !directoryExists.has(basePath)) { + await promises_1.default.mkdir(node_path_1.default.join(outputPath, basePath), { recursive: true }); + directoryExists.add(basePath); + } + // Copy file contents + await promises_1.default.copyFile(source, node_path_1.default.join(outputPath, destination), node_fs_1.constants.COPYFILE_FICLONE); + })); + } +} +function createOutputFileFromText(path, text) { + return { + path, + text, + get contents() { + return Buffer.from(this.text, 'utf-8'); + }, + }; +} +function createCodeBundleOptions(options, target, browsers, sourceFileCache) { + const { workspaceRoot, entryPoints, optimizationOptions, sourcemapOptions, tsconfig, outputNames, outExtension, fileReplacements, externalDependencies, preserveSymlinks, stylePreprocessorOptions, advancedOptimizations, inlineStyleLanguage, jit, tailwindConfiguration, } = options; + const buildOptions = { + absWorkingDir: workspaceRoot, + bundle: true, + format: 'esm', + entryPoints, + entryNames: outputNames.bundles, + assetNames: outputNames.media, + target, + supported: getFeatureSupport(target), + mainFields: ['es2020', 'browser', 'module', 'main'], + conditions: ['es2020', 'es2015', 'module'], + resolveExtensions: ['.ts', '.tsx', '.mjs', '.js'], + metafile: true, + legalComments: options.extractLicenses ? 'none' : 'eof', + logLevel: options.verbose ? 'debug' : 'silent', + minify: optimizationOptions.scripts, + pure: ['forwardRef'], + outdir: workspaceRoot, + outExtension: outExtension ? { '.js': `.${outExtension}` } : undefined, + sourcemap: sourcemapOptions.scripts && (sourcemapOptions.hidden ? 'external' : true), + splitting: true, + tsconfig, + external: externalDependencies, + write: false, + platform: 'browser', + preserveSymlinks, + plugins: [ + (0, sourcemap_ignorelist_plugin_1.createSourcemapIngorelistPlugin)(), + (0, compiler_plugin_1.createCompilerPlugin)( + // JS/TS options + { + sourcemap: !!sourcemapOptions.scripts, + thirdPartySourcemaps: sourcemapOptions.vendor, + tsconfig, + jit, + advancedOptimizations, + fileReplacements, + sourceFileCache, + loadResultCache: sourceFileCache?.loadResultCache, + }, + // Component stylesheet options + { + workspaceRoot, + optimization: !!optimizationOptions.styles.minify, + sourcemap: + // Hidden component stylesheet sourcemaps are inaccessible which is effectively + // the same as being disabled. Disabling has the advantage of avoiding the overhead + // of sourcemap processing. + !!sourcemapOptions.styles && (sourcemapOptions.hidden ? false : 'inline'), + outputNames, + includePaths: stylePreprocessorOptions?.includePaths, + externalDependencies, + target, + inlineStyleLanguage, + preserveSymlinks, + browsers, + tailwindConfiguration, + }), + ], + define: { + // Only set to false when script optimizations are enabled. It should not be set to true because + // Angular turns `ngDevMode` into an object for development debugging purposes when not defined + // which a constant true value would break. + ...(optimizationOptions.scripts ? { 'ngDevMode': 'false' } : undefined), + 'ngJitMode': jit ? 'true' : 'false', + }, + }; + const polyfills = options.polyfills ? [...options.polyfills] : []; + if (jit) { + polyfills.push('@angular/compiler'); + } + if (polyfills?.length) { + const namespace = 'angular:polyfills'; + buildOptions.entryPoints = { + ...buildOptions.entryPoints, + ['polyfills']: namespace, + }; + buildOptions.plugins?.unshift({ + name: 'angular-polyfills', + setup(build) { + build.onResolve({ filter: /^angular:polyfills$/ }, (args) => { + if (args.kind !== 'entry-point') { + return null; + } + return { + path: 'entry', + namespace, + }; + }); + build.onLoad({ filter: /./, namespace }, () => { + return { + contents: polyfills.map((file) => `import '${file.replace(/\\/g, '/')}';`).join('\n'), + loader: 'js', + resolveDir: workspaceRoot, + }; + }); + }, + }); + } + return buildOptions; +} +/** + * Generates a syntax feature object map for Angular applications based on a list of targets. + * A full set of feature names can be found here: https://esbuild.github.io/api/#supported + * @param target An array of browser/engine targets in the format accepted by the esbuild `target` option. + * @returns An object that can be used with the esbuild build `supported` option. + */ +function getFeatureSupport(target) { + const supported = { + // Native async/await is not supported with Zone.js. Disabling support here will cause + // esbuild to downlevel async/await and for await...of to a Zone.js supported form. However, esbuild + // does not currently support downleveling async generators. Instead babel is used within the JS/TS + // loader to perform the downlevel transformation. + // NOTE: If esbuild adds support in the future, the babel support for async generators can be disabled. + 'async-await': false, + // V8 currently has a performance defect involving object spread operations that can cause signficant + // degradation in runtime performance. By not supporting the language feature here, a downlevel form + // will be used instead which provides a workaround for the performance issue. + // For more details: https://bugs.chromium.org/p/v8/issues/detail?id=11536 + 'object-rest-spread': false, + // esbuild currently has a defect involving self-referencing a class within a static code block or + // static field initializer. This is not an issue for projects that use the default browserslist as these + // elements are an ES2022 feature which is not support by all browsers in the default list. However, if a + // custom browserslist is used that only has newer browsers than the static code elements may be present. + // This issue is compounded by the default usage of the tsconfig `"useDefineForClassFields": false` option + // present in generated CLI projects which causes static code blocks to be used instead of static fields. + // esbuild currently unconditionally downlevels all static fields in top-level classes so to workaround the + // Angular issue only static code blocks are disabled here. + // For more details: https://github.com/evanw/esbuild/issues/2950 + 'class-static-blocks': false, + }; + // Detect Safari browser versions that have a class field behavior bug + // See: https://github.com/angular/angular-cli/issues/24355#issuecomment-1333477033 + // See: https://github.com/WebKit/WebKit/commit/e8788a34b3d5f5b4edd7ff6450b80936bff396f2 + let safariClassFieldScopeBug = false; + for (const browser of target) { + let majorVersion; + if (browser.startsWith('ios')) { + majorVersion = Number(browser.slice(3, 5)); + } + else if (browser.startsWith('safari')) { + majorVersion = Number(browser.slice(6, 8)); + } + else { + continue; + } + // Technically, 14.0 is not broken but rather does not have support. However, the behavior + // is identical since it would be set to false by esbuild if present as a target. + if (majorVersion === 14 || majorVersion === 15) { + safariClassFieldScopeBug = true; + break; + } + } + // If class field support cannot be used set to false; otherwise leave undefined to allow + // esbuild to use `target` to determine support. + if (safariClassFieldScopeBug) { + supported['class-field'] = false; + supported['class-static-field'] = false; + } + return supported; +} +async function withSpinner(text, action) { + const spinner = new spinner_1.Spinner(text); + spinner.start(); + try { + return await action(); + } + finally { + spinner.stop(); + } +} +async function withNoProgress(test, action) { + return action(); +} +/** + * Main execution function for the esbuild-based application builder. + * The options are compatible with the Webpack-based builder. + * @param userOptions The browser builder options to use when setting up the application build + * @param context The Architect builder context object + * @returns An async iterable with the builder result output + */ +function buildEsbuildBrowser(userOptions, context, infrastructureSettings) { + return buildEsbuildBrowserInternal(userOptions, context, infrastructureSettings); +} +exports.buildEsbuildBrowser = buildEsbuildBrowser; +/** + * Internal version of the main execution function for the esbuild-based application builder. + * Exposes some additional "private" options in addition to those exposed by the schema. + * @param userOptions The browser-esbuild builder options to use when setting up the application build + * @param context The Architect builder context object + * @returns An async iterable with the builder result output + */ +async function* buildEsbuildBrowserInternal(userOptions, context, infrastructureSettings) { + // Inform user of status of builder and options + (0, builder_status_warnings_1.logBuilderStatusWarnings)(userOptions, context); + // Determine project name from builder context target + const projectName = context.target?.project; + if (!projectName) { + context.logger.error(`The 'browser-esbuild' builder requires a target to be specified.`); + return; + } + const normalizedOptions = await (0, options_1.normalizeOptions)(context, projectName, userOptions); + // Writing the result to the filesystem is the default behavior + const shouldWriteResult = infrastructureSettings?.write !== false; + if (shouldWriteResult) { + // Clean output path if enabled + if (userOptions.deleteOutputPath) { + if (normalizedOptions.outputPath === normalizedOptions.workspaceRoot) { + context.logger.error('Output path MUST not be workspace root directory!'); + return; + } + await promises_1.default.rm(normalizedOptions.outputPath, { force: true, recursive: true, maxRetries: 3 }); + } + // Create output directory if needed + try { + await promises_1.default.mkdir(normalizedOptions.outputPath, { recursive: true }); + } + catch (e) { + (0, error_1.assertIsError)(e); + context.logger.error('Unable to create output directory: ' + e.message); + return; + } + } + const withProgress = normalizedOptions.progress + ? withSpinner + : withNoProgress; + // Initial build + let result; + try { + result = await withProgress('Building...', () => execute(normalizedOptions, context)); + if (shouldWriteResult) { + // Write output files + await writeResultFiles(result.outputFiles, result.assetFiles, normalizedOptions.outputPath); + yield result.output; + } + else { + // Requires casting due to unneeded `JsonObject` requirement. Remove once fixed. + // eslint-disable-next-line @typescript-eslint/no-explicit-any + yield result.outputWithFiles; + } + // Finish if watch mode is not enabled + if (!userOptions.watch) { + return; + } + } + finally { + // Ensure Sass workers are shutdown if not watching + if (!userOptions.watch) { + (0, sass_plugin_1.shutdownSassWorkerPool)(); + } + } + if (normalizedOptions.progress) { + context.logger.info('Watch mode enabled. Watching for file changes...'); + } + // Setup a watcher + const { createWatcher } = await Promise.resolve().then(() => __importStar(require('./watcher'))); + const watcher = createWatcher({ + polling: typeof userOptions.poll === 'number', + interval: userOptions.poll, + ignored: [ + // Ignore the output and cache paths to avoid infinite rebuild cycles + normalizedOptions.outputPath, + normalizedOptions.cacheOptions.basePath, + // Ignore all node modules directories to avoid excessive file watchers. + // Package changes are handled below by watching manifest and lock files. + '**/node_modules/**', + ], + }); + // Temporarily watch the entire project + watcher.add(normalizedOptions.projectRoot); + // Watch workspace for package manager changes + const packageWatchFiles = [ + // manifest can affect module resolution + 'package.json', + // npm lock file + 'package-lock.json', + // pnpm lock file + 'pnpm-lock.yaml', + // yarn lock file including Yarn PnP manifest files (https://yarnpkg.com/advanced/pnp-spec/) + 'yarn.lock', + '.pnp.cjs', + '.pnp.data.json', + ]; + watcher.add(packageWatchFiles.map((file) => node_path_1.default.join(normalizedOptions.workspaceRoot, file))); + // Wait for changes and rebuild as needed + try { + for await (const changes of watcher) { + if (userOptions.verbose) { + context.logger.info(changes.toDebugString()); + } + result = await withProgress('Changes detected. Rebuilding...', () => execute(normalizedOptions, context, result.createRebuildState(changes))); + if (shouldWriteResult) { + // Write output files + await writeResultFiles(result.outputFiles, result.assetFiles, normalizedOptions.outputPath); + yield result.output; + } + else { + // Requires casting due to unneeded `JsonObject` requirement. Remove once fixed. + // eslint-disable-next-line @typescript-eslint/no-explicit-any + yield result.outputWithFiles; + } + } + } + finally { + // Stop the watcher + await watcher.close(); + // Cleanup incremental rebuild state + await result.dispose(); + (0, sass_plugin_1.shutdownSassWorkerPool)(); + } +} +exports.buildEsbuildBrowserInternal = buildEsbuildBrowserInternal; +exports.default = (0, architect_1.createBuilder)(buildEsbuildBrowser); +function logBuildStats(context, metafile, initialFiles) { + const initial = new Map(initialFiles.map((info) => [info.file, info.name])); + const stats = []; + for (const [file, output] of Object.entries(metafile.outputs)) { + // Only display JavaScript and CSS files + if (!file.endsWith('.js') && !file.endsWith('.css')) { + continue; + } + // Skip internal component resources + // eslint-disable-next-line @typescript-eslint/no-explicit-any + if (output['ng-component']) { + continue; + } + stats.push({ + initial: initial.has(file), + stats: [file, initial.get(file) ?? '-', output.bytes, ''], + }); + } + const tableText = (0, stats_1.generateBuildStatsTable)(stats, true, true, false, undefined); + context.logger.info('\n' + tableText + '\n'); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/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 { BuilderContext, BuilderOutput, createBuilder } from '@angular-devkit/architect';\nimport type { BuildOptions, Metafile, OutputFile } from 'esbuild';\nimport { constants as fsConstants } from 'node:fs';\nimport fs from 'node:fs/promises';\nimport path from 'node:path';\nimport { copyAssets } from '../../utils/copy-assets';\nimport { assertIsError } from '../../utils/error';\nimport { transformSupportedBrowsersToTargets } from '../../utils/esbuild-targets';\nimport { FileInfo } from '../../utils/index-file/augment-index-html';\nimport { IndexHtmlGenerator } from '../../utils/index-file/index-html-generator';\nimport { augmentAppWithServiceWorkerEsbuild } from '../../utils/service-worker';\nimport { Spinner } from '../../utils/spinner';\nimport { getSupportedBrowsers } from '../../utils/supported-browsers';\nimport { BundleStats, generateBuildStatsTable } from '../../webpack/utils/stats';\nimport { SourceFileCache, createCompilerPlugin } from './angular/compiler-plugin';\nimport { logBuilderStatusWarnings } from './builder-status-warnings';\nimport { checkCommonJSModules } from './commonjs-checker';\nimport { BundlerContext, logMessages } from './esbuild';\nimport { createGlobalScriptsBundleOptions } from './global-scripts';\nimport { createGlobalStylesBundleOptions } from './global-styles';\nimport { extractLicenses } from './license-extractor';\nimport { BrowserEsbuildOptions, NormalizedBrowserOptions, normalizeOptions } from './options';\nimport { Schema as BrowserBuilderOptions } from './schema';\nimport { createSourcemapIngorelistPlugin } from './sourcemap-ignorelist-plugin';\nimport { shutdownSassWorkerPool } from './stylesheets/sass-plugin';\nimport type { ChangedFiles } from './watcher';\n\ninterface RebuildState {\n  rebuildContexts: BundlerContext[];\n  codeBundleCache?: SourceFileCache;\n  fileChanges: ChangedFiles;\n}\n\n/**\n * Represents the result of a single builder execute call.\n */\nclass ExecutionResult {\n  readonly outputFiles: OutputFile[] = [];\n  readonly assetFiles: { source: string; destination: string }[] = [];\n\n  constructor(\n    private rebuildContexts: BundlerContext[],\n    private codeBundleCache?: SourceFileCache,\n  ) {}\n\n  addOutputFile(path: string, content: string): void {\n    this.outputFiles.push(createOutputFileFromText(path, content));\n  }\n\n  get output() {\n    return {\n      success: this.outputFiles.length > 0,\n    };\n  }\n\n  get outputWithFiles() {\n    return {\n      success: this.outputFiles.length > 0,\n      outputFiles: this.outputFiles,\n      assetFiles: this.assetFiles,\n    };\n  }\n\n  createRebuildState(fileChanges: ChangedFiles): RebuildState {\n    this.codeBundleCache?.invalidate([...fileChanges.modified, ...fileChanges.removed]);\n\n    return {\n      rebuildContexts: this.rebuildContexts,\n      codeBundleCache: this.codeBundleCache,\n      fileChanges,\n    };\n  }\n\n  async dispose(): Promise<void> {\n    await Promise.allSettled(this.rebuildContexts.map((context) => context.dispose()));\n  }\n}\n\nasync function execute(\n  options: NormalizedBrowserOptions,\n  context: BuilderContext,\n  rebuildState?: RebuildState,\n): Promise<ExecutionResult> {\n  const startTime = process.hrtime.bigint();\n\n  const {\n    projectRoot,\n    workspaceRoot,\n    optimizationOptions,\n    assets,\n    serviceWorkerOptions,\n    indexHtmlOptions,\n  } = options;\n\n  const browsers = getSupportedBrowsers(projectRoot, context.logger);\n  const target = transformSupportedBrowsersToTargets(browsers);\n\n  // Reuse rebuild state or create new bundle contexts for code and global stylesheets\n  let bundlerContexts = rebuildState?.rebuildContexts;\n  const codeBundleCache = options.watch\n    ? rebuildState?.codeBundleCache ?? new SourceFileCache()\n    : undefined;\n  if (bundlerContexts === undefined) {\n    bundlerContexts = [];\n\n    // Application code\n    bundlerContexts.push(\n      new BundlerContext(\n        workspaceRoot,\n        !!options.watch,\n        createCodeBundleOptions(options, target, browsers, codeBundleCache),\n      ),\n    );\n\n    // Global Stylesheets\n    if (options.globalStyles.length > 0) {\n      for (const initial of [true, false]) {\n        const bundleOptions = createGlobalStylesBundleOptions(\n          options,\n          target,\n          browsers,\n          initial,\n          codeBundleCache?.loadResultCache,\n        );\n        if (bundleOptions) {\n          bundlerContexts.push(new BundlerContext(workspaceRoot, !!options.watch, bundleOptions));\n        }\n      }\n    }\n\n    // Global Scripts\n    if (options.globalScripts.length > 0) {\n      for (const initial of [true, false]) {\n        const bundleOptions = createGlobalScriptsBundleOptions(options, initial);\n        if (bundleOptions) {\n          bundlerContexts.push(new BundlerContext(workspaceRoot, !!options.watch, bundleOptions));\n        }\n      }\n    }\n  }\n\n  const bundlingResult = await BundlerContext.bundleAll(bundlerContexts);\n\n  // Log all warnings and errors generated during bundling\n  await logMessages(context, bundlingResult);\n\n  const executionResult = new ExecutionResult(bundlerContexts, codeBundleCache);\n\n  // Return if the bundling has errors\n  if (bundlingResult.errors) {\n    return executionResult;\n  }\n\n  // Filter global stylesheet initial files. Currently all initial CSS files are from the global styles option.\n  if (options.globalStyles.length > 0) {\n    bundlingResult.initialFiles = bundlingResult.initialFiles.filter(\n      ({ file, name }) =>\n        !file.endsWith('.css') ||\n        options.globalStyles.find((style) => style.name === name)?.initial,\n    );\n  }\n\n  const { metafile, initialFiles, outputFiles } = bundlingResult;\n\n  executionResult.outputFiles.push(...outputFiles);\n\n  // Check metafile for CommonJS module usage if optimizing scripts\n  if (optimizationOptions.scripts) {\n    const messages = checkCommonJSModules(metafile, options.allowedCommonJsDependencies);\n    await logMessages(context, { warnings: messages });\n  }\n\n  // Generate index HTML file\n  if (indexHtmlOptions) {\n    // Create an index HTML generator that reads from the in-memory output files\n    const indexHtmlGenerator = new IndexHtmlGenerator({\n      indexPath: indexHtmlOptions.input,\n      entrypoints: indexHtmlOptions.insertionOrder,\n      sri: options.subresourceIntegrity,\n      optimization: optimizationOptions,\n      crossOrigin: options.crossOrigin,\n    });\n\n    /** Virtual output path to support reading in-memory files. */\n    const virtualOutputPath = '/';\n    indexHtmlGenerator.readAsset = async function (filePath: string): Promise<string> {\n      // Remove leading directory separator\n      const relativefilePath = path.relative(virtualOutputPath, filePath);\n      const file = executionResult.outputFiles.find((file) => file.path === relativefilePath);\n      if (file) {\n        return file.text;\n      }\n\n      throw new Error(`Output file does not exist: ${path}`);\n    };\n\n    const { content, warnings, errors } = await indexHtmlGenerator.process({\n      baseHref: options.baseHref,\n      lang: undefined,\n      outputPath: virtualOutputPath,\n      files: initialFiles,\n    });\n\n    for (const error of errors) {\n      context.logger.error(error);\n    }\n    for (const warning of warnings) {\n      context.logger.warn(warning);\n    }\n\n    executionResult.addOutputFile(indexHtmlOptions.output, content);\n  }\n\n  // Copy assets\n  if (assets) {\n    // The webpack copy assets helper is used with no base paths defined. This prevents the helper\n    // from directly writing to disk. This should eventually be replaced with a more optimized helper.\n    executionResult.assetFiles.push(...(await copyAssets(assets, [], workspaceRoot)));\n  }\n\n  // Write metafile if stats option is enabled\n  if (options.stats) {\n    executionResult.addOutputFile('stats.json', JSON.stringify(metafile, null, 2));\n  }\n\n  // Extract and write licenses for used packages\n  if (options.extractLicenses) {\n    executionResult.addOutputFile(\n      '3rdpartylicenses.txt',\n      await extractLicenses(metafile, workspaceRoot),\n    );\n  }\n\n  // Augment the application with service worker support\n  if (serviceWorkerOptions) {\n    try {\n      const serviceWorkerResult = await augmentAppWithServiceWorkerEsbuild(\n        workspaceRoot,\n        serviceWorkerOptions,\n        options.baseHref || '/',\n        executionResult.outputFiles,\n        executionResult.assetFiles,\n      );\n      executionResult.addOutputFile('ngsw.json', serviceWorkerResult.manifest);\n      executionResult.assetFiles.push(...serviceWorkerResult.assetFiles);\n    } catch (error) {\n      context.logger.error(error instanceof Error ? error.message : `${error}`);\n\n      return executionResult;\n    }\n  }\n\n  logBuildStats(context, metafile, initialFiles);\n\n  const buildTime = Number(process.hrtime.bigint() - startTime) / 10 ** 9;\n  context.logger.info(`Application bundle generation complete. [${buildTime.toFixed(3)} seconds]`);\n\n  return executionResult;\n}\n\nasync function writeResultFiles(\n  outputFiles: OutputFile[],\n  assetFiles: { source: string; destination: string }[] | undefined,\n  outputPath: string,\n) {\n  const directoryExists = new Set<string>();\n  await Promise.all(\n    outputFiles.map(async (file) => {\n      // Ensure output subdirectories exist\n      const basePath = path.dirname(file.path);\n      if (basePath && !directoryExists.has(basePath)) {\n        await fs.mkdir(path.join(outputPath, basePath), { recursive: true });\n        directoryExists.add(basePath);\n      }\n      // Write file contents\n      await fs.writeFile(path.join(outputPath, file.path), file.contents);\n    }),\n  );\n\n  if (assetFiles?.length) {\n    await Promise.all(\n      assetFiles.map(async ({ source, destination }) => {\n        // Ensure output subdirectories exist\n        const basePath = path.dirname(destination);\n        if (basePath && !directoryExists.has(basePath)) {\n          await fs.mkdir(path.join(outputPath, basePath), { recursive: true });\n          directoryExists.add(basePath);\n        }\n        // Copy file contents\n        await fs.copyFile(source, path.join(outputPath, destination), fsConstants.COPYFILE_FICLONE);\n      }),\n    );\n  }\n}\n\nfunction createOutputFileFromText(path: string, text: string): OutputFile {\n  return {\n    path,\n    text,\n    get contents() {\n      return Buffer.from(this.text, 'utf-8');\n    },\n  };\n}\n\nfunction createCodeBundleOptions(\n  options: NormalizedBrowserOptions,\n  target: string[],\n  browsers: string[],\n  sourceFileCache?: SourceFileCache,\n): BuildOptions {\n  const {\n    workspaceRoot,\n    entryPoints,\n    optimizationOptions,\n    sourcemapOptions,\n    tsconfig,\n    outputNames,\n    outExtension,\n    fileReplacements,\n    externalDependencies,\n    preserveSymlinks,\n    stylePreprocessorOptions,\n    advancedOptimizations,\n    inlineStyleLanguage,\n    jit,\n    tailwindConfiguration,\n  } = options;\n\n  const buildOptions: BuildOptions = {\n    absWorkingDir: workspaceRoot,\n    bundle: true,\n    format: 'esm',\n    entryPoints,\n    entryNames: outputNames.bundles,\n    assetNames: outputNames.media,\n    target,\n    supported: getFeatureSupport(target),\n    mainFields: ['es2020', 'browser', 'module', 'main'],\n    conditions: ['es2020', 'es2015', 'module'],\n    resolveExtensions: ['.ts', '.tsx', '.mjs', '.js'],\n    metafile: true,\n    legalComments: options.extractLicenses ? 'none' : 'eof',\n    logLevel: options.verbose ? 'debug' : 'silent',\n    minify: optimizationOptions.scripts,\n    pure: ['forwardRef'],\n    outdir: workspaceRoot,\n    outExtension: outExtension ? { '.js': `.${outExtension}` } : undefined,\n    sourcemap: sourcemapOptions.scripts && (sourcemapOptions.hidden ? 'external' : true),\n    splitting: true,\n    tsconfig,\n    external: externalDependencies,\n    write: false,\n    platform: 'browser',\n    preserveSymlinks,\n    plugins: [\n      createSourcemapIngorelistPlugin(),\n      createCompilerPlugin(\n        // JS/TS options\n        {\n          sourcemap: !!sourcemapOptions.scripts,\n          thirdPartySourcemaps: sourcemapOptions.vendor,\n          tsconfig,\n          jit,\n          advancedOptimizations,\n          fileReplacements,\n          sourceFileCache,\n          loadResultCache: sourceFileCache?.loadResultCache,\n        },\n        // Component stylesheet options\n        {\n          workspaceRoot,\n          optimization: !!optimizationOptions.styles.minify,\n          sourcemap:\n            // Hidden component stylesheet sourcemaps are inaccessible which is effectively\n            // the same as being disabled. Disabling has the advantage of avoiding the overhead\n            // of sourcemap processing.\n            !!sourcemapOptions.styles && (sourcemapOptions.hidden ? false : 'inline'),\n          outputNames,\n          includePaths: stylePreprocessorOptions?.includePaths,\n          externalDependencies,\n          target,\n          inlineStyleLanguage,\n          preserveSymlinks,\n          browsers,\n          tailwindConfiguration,\n        },\n      ),\n    ],\n    define: {\n      // Only set to false when script optimizations are enabled. It should not be set to true because\n      // Angular turns `ngDevMode` into an object for development debugging purposes when not defined\n      // which a constant true value would break.\n      ...(optimizationOptions.scripts ? { 'ngDevMode': 'false' } : undefined),\n      'ngJitMode': jit ? 'true' : 'false',\n    },\n  };\n\n  const polyfills = options.polyfills ? [...options.polyfills] : [];\n  if (jit) {\n    polyfills.push('@angular/compiler');\n  }\n\n  if (polyfills?.length) {\n    const namespace = 'angular:polyfills';\n    buildOptions.entryPoints = {\n      ...buildOptions.entryPoints,\n      ['polyfills']: namespace,\n    };\n\n    buildOptions.plugins?.unshift({\n      name: 'angular-polyfills',\n      setup(build) {\n        build.onResolve({ filter: /^angular:polyfills$/ }, (args) => {\n          if (args.kind !== 'entry-point') {\n            return null;\n          }\n\n          return {\n            path: 'entry',\n            namespace,\n          };\n        });\n        build.onLoad({ filter: /./, namespace }, () => {\n          return {\n            contents: polyfills.map((file) => `import '${file.replace(/\\\\/g, '/')}';`).join('\\n'),\n            loader: 'js',\n            resolveDir: workspaceRoot,\n          };\n        });\n      },\n    });\n  }\n\n  return buildOptions;\n}\n\n/**\n * Generates a syntax feature object map for Angular applications based on a list of targets.\n * A full set of feature names can be found here: https://esbuild.github.io/api/#supported\n * @param target An array of browser/engine targets in the format accepted by the esbuild `target` option.\n * @returns An object that can be used with the esbuild build `supported` option.\n */\nfunction getFeatureSupport(target: string[]): BuildOptions['supported'] {\n  const supported: Record<string, boolean> = {\n    // Native async/await is not supported with Zone.js. Disabling support here will cause\n    // esbuild to downlevel async/await and for await...of to a Zone.js supported form. However, esbuild\n    // does not currently support downleveling async generators. Instead babel is used within the JS/TS\n    // loader to perform the downlevel transformation.\n    // NOTE: If esbuild adds support in the future, the babel support for async generators can be disabled.\n    'async-await': false,\n    // V8 currently has a performance defect involving object spread operations that can cause signficant\n    // degradation in runtime performance. By not supporting the language feature here, a downlevel form\n    // will be used instead which provides a workaround for the performance issue.\n    // For more details: https://bugs.chromium.org/p/v8/issues/detail?id=11536\n    'object-rest-spread': false,\n    // esbuild currently has a defect involving self-referencing a class within a static code block or\n    // static field initializer. This is not an issue for projects that use the default browserslist as these\n    // elements are an ES2022 feature which is not support by all browsers in the default list. However, if a\n    // custom browserslist is used that only has newer browsers than the static code elements may be present.\n    // This issue is compounded by the default usage of the tsconfig `\"useDefineForClassFields\": false` option\n    // present in generated CLI projects which causes static code blocks to be used instead of static fields.\n    // esbuild currently unconditionally downlevels all static fields in top-level classes so to workaround the\n    // Angular issue only static code blocks are disabled here.\n    // For more details: https://github.com/evanw/esbuild/issues/2950\n    'class-static-blocks': false,\n  };\n\n  // Detect Safari browser versions that have a class field behavior bug\n  // See: https://github.com/angular/angular-cli/issues/24355#issuecomment-1333477033\n  // See: https://github.com/WebKit/WebKit/commit/e8788a34b3d5f5b4edd7ff6450b80936bff396f2\n  let safariClassFieldScopeBug = false;\n  for (const browser of target) {\n    let majorVersion;\n    if (browser.startsWith('ios')) {\n      majorVersion = Number(browser.slice(3, 5));\n    } else if (browser.startsWith('safari')) {\n      majorVersion = Number(browser.slice(6, 8));\n    } else {\n      continue;\n    }\n    // Technically, 14.0 is not broken but rather does not have support. However, the behavior\n    // is identical since it would be set to false by esbuild if present as a target.\n    if (majorVersion === 14 || majorVersion === 15) {\n      safariClassFieldScopeBug = true;\n      break;\n    }\n  }\n  // If class field support cannot be used set to false; otherwise leave undefined to allow\n  // esbuild to use `target` to determine support.\n  if (safariClassFieldScopeBug) {\n    supported['class-field'] = false;\n    supported['class-static-field'] = false;\n  }\n\n  return supported;\n}\n\nasync function withSpinner<T>(text: string, action: () => T | Promise<T>): Promise<T> {\n  const spinner = new Spinner(text);\n  spinner.start();\n\n  try {\n    return await action();\n  } finally {\n    spinner.stop();\n  }\n}\n\nasync function withNoProgress<T>(test: string, action: () => T | Promise<T>): Promise<T> {\n  return action();\n}\n\n/**\n * Main execution function for the esbuild-based application builder.\n * The options are compatible with the Webpack-based builder.\n * @param userOptions The browser builder options to use when setting up the application build\n * @param context The Architect builder context object\n * @returns An async iterable with the builder result output\n */\nexport function buildEsbuildBrowser(\n  userOptions: BrowserBuilderOptions,\n  context: BuilderContext,\n  infrastructureSettings?: {\n    write?: boolean;\n  },\n): AsyncIterable<\n  BuilderOutput & {\n    outputFiles?: OutputFile[];\n    assetFiles?: { source: string; destination: string }[];\n  }\n> {\n  return buildEsbuildBrowserInternal(userOptions, context, infrastructureSettings);\n}\n\n/**\n * Internal version of the main execution function for the esbuild-based application builder.\n * Exposes some additional \"private\" options in addition to those exposed by the schema.\n * @param userOptions The browser-esbuild builder options to use when setting up the application build\n * @param context The Architect builder context object\n * @returns An async iterable with the builder result output\n */\nexport async function* buildEsbuildBrowserInternal(\n  userOptions: BrowserEsbuildOptions,\n  context: BuilderContext,\n  infrastructureSettings?: {\n    write?: boolean;\n  },\n): AsyncIterable<\n  BuilderOutput & {\n    outputFiles?: OutputFile[];\n    assetFiles?: { source: string; destination: string }[];\n  }\n> {\n  // Inform user of status of builder and options\n  logBuilderStatusWarnings(userOptions, context);\n\n  // Determine project name from builder context target\n  const projectName = context.target?.project;\n  if (!projectName) {\n    context.logger.error(`The 'browser-esbuild' builder requires a target to be specified.`);\n\n    return;\n  }\n\n  const normalizedOptions = await normalizeOptions(context, projectName, userOptions);\n  // Writing the result to the filesystem is the default behavior\n  const shouldWriteResult = infrastructureSettings?.write !== false;\n\n  if (shouldWriteResult) {\n    // Clean output path if enabled\n    if (userOptions.deleteOutputPath) {\n      if (normalizedOptions.outputPath === normalizedOptions.workspaceRoot) {\n        context.logger.error('Output path MUST not be workspace root directory!');\n\n        return;\n      }\n\n      await fs.rm(normalizedOptions.outputPath, { force: true, recursive: true, maxRetries: 3 });\n    }\n\n    // Create output directory if needed\n    try {\n      await fs.mkdir(normalizedOptions.outputPath, { recursive: true });\n    } catch (e) {\n      assertIsError(e);\n      context.logger.error('Unable to create output directory: ' + e.message);\n\n      return;\n    }\n  }\n\n  const withProgress: typeof withSpinner = normalizedOptions.progress\n    ? withSpinner\n    : withNoProgress;\n\n  // Initial build\n  let result: ExecutionResult;\n  try {\n    result = await withProgress('Building...', () => execute(normalizedOptions, context));\n\n    if (shouldWriteResult) {\n      // Write output files\n      await writeResultFiles(result.outputFiles, result.assetFiles, normalizedOptions.outputPath);\n\n      yield result.output;\n    } else {\n      // Requires casting due to unneeded `JsonObject` requirement. Remove once fixed.\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      yield result.outputWithFiles as any;\n    }\n\n    // Finish if watch mode is not enabled\n    if (!userOptions.watch) {\n      return;\n    }\n  } finally {\n    // Ensure Sass workers are shutdown if not watching\n    if (!userOptions.watch) {\n      shutdownSassWorkerPool();\n    }\n  }\n\n  if (normalizedOptions.progress) {\n    context.logger.info('Watch mode enabled. Watching for file changes...');\n  }\n\n  // Setup a watcher\n  const { createWatcher } = await import('./watcher');\n  const watcher = createWatcher({\n    polling: typeof userOptions.poll === 'number',\n    interval: userOptions.poll,\n    ignored: [\n      // Ignore the output and cache paths to avoid infinite rebuild cycles\n      normalizedOptions.outputPath,\n      normalizedOptions.cacheOptions.basePath,\n      // Ignore all node modules directories to avoid excessive file watchers.\n      // Package changes are handled below by watching manifest and lock files.\n      '**/node_modules/**',\n    ],\n  });\n\n  // Temporarily watch the entire project\n  watcher.add(normalizedOptions.projectRoot);\n\n  // Watch workspace for package manager changes\n  const packageWatchFiles = [\n    // manifest can affect module resolution\n    'package.json',\n    // npm lock file\n    'package-lock.json',\n    // pnpm lock file\n    'pnpm-lock.yaml',\n    // yarn lock file including Yarn PnP manifest files (https://yarnpkg.com/advanced/pnp-spec/)\n    'yarn.lock',\n    '.pnp.cjs',\n    '.pnp.data.json',\n  ];\n  watcher.add(packageWatchFiles.map((file) => path.join(normalizedOptions.workspaceRoot, file)));\n\n  // Wait for changes and rebuild as needed\n  try {\n    for await (const changes of watcher) {\n      if (userOptions.verbose) {\n        context.logger.info(changes.toDebugString());\n      }\n\n      result = await withProgress('Changes detected. Rebuilding...', () =>\n        execute(normalizedOptions, context, result.createRebuildState(changes)),\n      );\n\n      if (shouldWriteResult) {\n        // Write output files\n        await writeResultFiles(result.outputFiles, result.assetFiles, normalizedOptions.outputPath);\n\n        yield result.output;\n      } else {\n        // Requires casting due to unneeded `JsonObject` requirement. Remove once fixed.\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        yield result.outputWithFiles as any;\n      }\n    }\n  } finally {\n    // Stop the watcher\n    await watcher.close();\n    // Cleanup incremental rebuild state\n    await result.dispose();\n    shutdownSassWorkerPool();\n  }\n}\n\nexport default createBuilder(buildEsbuildBrowser);\n\nfunction logBuildStats(context: BuilderContext, metafile: Metafile, initialFiles: FileInfo[]) {\n  const initial = new Map(initialFiles.map((info) => [info.file, info.name]));\n  const stats: BundleStats[] = [];\n  for (const [file, output] of Object.entries(metafile.outputs)) {\n    // Only display JavaScript and CSS files\n    if (!file.endsWith('.js') && !file.endsWith('.css')) {\n      continue;\n    }\n    // Skip internal component resources\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    if ((output as any)['ng-component']) {\n      continue;\n    }\n\n    stats.push({\n      initial: initial.has(file),\n      stats: [file, initial.get(file) ?? '-', output.bytes, ''],\n    });\n  }\n\n  const tableText = generateBuildStatsTable(stats, true, true, false, undefined);\n\n  context.logger.info('\\n' + tableText + '\\n');\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/javascript-transformer-worker.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/javascript-transformer-worker.d.ts new file mode 100644 index 00000000..df56c0ba --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/javascript-transformer-worker.d.ts @@ -0,0 +1,19 @@ +/** + * @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 + */ +interface JavaScriptTransformRequest { + filename: string; + data: string; + sourcemap: boolean; + thirdPartySourcemaps: boolean; + advancedOptimizations: boolean; + forceAsyncTransformation?: boolean; + skipLinker: boolean; + jit: boolean; +} +export default function transformJavaScript(request: JavaScriptTransformRequest): Promise; +export {}; diff --git a/artifacts/build-angular/src/builders/browser-esbuild/javascript-transformer-worker.js b/artifacts/build-angular/src/builders/browser-esbuild/javascript-transformer-worker.js new file mode 100644 index 00000000..febb7220 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/javascript-transformer-worker.js @@ -0,0 +1,76 @@ +"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 __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const core_1 = require("@babel/core"); +const promises_1 = require("node:fs/promises"); +const application_1 = __importDefault(require("../../babel/presets/application")); +const webpack_loader_1 = require("../../babel/webpack-loader"); +const load_esm_1 = require("../../utils/load-esm"); +async function transformJavaScript(request) { + request.data ?? (request.data = await (0, promises_1.readFile)(request.filename, 'utf-8')); + const transformedData = await transformWithBabel(request); + return Buffer.from(transformedData, 'utf-8'); +} +exports.default = transformJavaScript; +let linkerPluginCreator; +async function transformWithBabel({ filename, data, ...options }) { + const forceAsyncTransformation = options.forceAsyncTransformation ?? + (!/[\\/][_f]?esm2015[\\/]/.test(filename) && /async(?:\s+function)?\s*\*/.test(data)); + const shouldLink = !options.skipLinker && (await (0, webpack_loader_1.requiresLinking)(filename, data)); + const useInputSourcemap = options.sourcemap && + (!!options.thirdPartySourcemaps || !/[\\/]node_modules[\\/]/.test(filename)); + // If no additional transformations are needed, return the data directly + if (!forceAsyncTransformation && !options.advancedOptimizations && !shouldLink) { + // Strip sourcemaps if they should not be used + return useInputSourcemap ? data : data.replace(/^\/\/# sourceMappingURL=[^\r\n]*/gm, ''); + } + // @angular/platform-server/init entry-point has side-effects. + const safeAngularPackage = /[\\/]node_modules[\\/]@angular[\\/]/.test(filename) && + !/@angular[\\/]platform-server[\\/]f?esm2022[\\/]init/.test(filename); + // Lazy load the linker plugin only when linking is required + if (shouldLink) { + linkerPluginCreator ?? (linkerPluginCreator = (await (0, load_esm_1.loadEsmModule)('@angular/compiler-cli/linker/babel')).createEs2015LinkerPlugin); + } + const result = await (0, core_1.transformAsync)(data, { + filename, + inputSourceMap: (useInputSourcemap ? undefined : false), + sourceMaps: useInputSourcemap ? 'inline' : false, + compact: false, + configFile: false, + babelrc: false, + browserslistConfigFile: false, + plugins: [], + presets: [ + [ + application_1.default, + { + angularLinker: linkerPluginCreator && { + shouldLink, + jitMode: options.jit, + linkerPluginCreator, + }, + forceAsyncTransformation, + optimize: options.advancedOptimizations && { + pureTopLevel: safeAngularPackage, + }, + }, + ], + ], + }); + const outputCode = result?.code ?? data; + // Strip sourcemaps if they should not be used. + // Babel will keep the original comments even if sourcemaps are disabled. + return useInputSourcemap + ? outputCode + : outputCode.replace(/^\/\/# sourceMappingURL=[^\r\n]*/gm, ''); +} +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiamF2YXNjcmlwdC10cmFuc2Zvcm1lci13b3JrZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9hbmd1bGFyX2RldmtpdC9idWlsZF9hbmd1bGFyL3NyYy9idWlsZGVycy9icm93c2VyLWVzYnVpbGQvamF2YXNjcmlwdC10cmFuc2Zvcm1lci13b3JrZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7R0FNRzs7Ozs7QUFFSCxzQ0FBNkM7QUFDN0MsK0NBQTRDO0FBQzVDLGtGQUF1RTtBQUN2RSwrREFBNkQ7QUFDN0QsbURBQXFEO0FBYXRDLEtBQUssVUFBVSxtQkFBbUIsQ0FDL0MsT0FBbUM7SUFFbkMsT0FBTyxDQUFDLElBQUksS0FBWixPQUFPLENBQUMsSUFBSSxHQUFLLE1BQU0sSUFBQSxtQkFBUSxFQUFDLE9BQU8sQ0FBQyxRQUFRLEVBQUUsT0FBTyxDQUFDLEVBQUM7SUFDM0QsTUFBTSxlQUFlLEdBQUcsTUFBTSxrQkFBa0IsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUUxRCxPQUFPLE1BQU0sQ0FBQyxJQUFJLENBQUMsZUFBZSxFQUFFLE9BQU8sQ0FBQyxDQUFDO0FBQy9DLENBQUM7QUFQRCxzQ0FPQztBQUVELElBQUksbUJBRVMsQ0FBQztBQUVkLEtBQUssVUFBVSxrQkFBa0IsQ0FBQyxFQUNoQyxRQUFRLEVBQ1IsSUFBSSxFQUNKLEdBQUcsT0FBTyxFQUNpQjtJQUMzQixNQUFNLHdCQUF3QixHQUM1QixPQUFPLENBQUMsd0JBQXdCO1FBQ2hDLENBQUMsQ0FBQyx3QkFBd0IsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLElBQUksNEJBQTRCLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7SUFDeEYsTUFBTSxVQUFVLEdBQUcsQ0FBQyxPQUFPLENBQUMsVUFBVSxJQUFJLENBQUMsTUFBTSxJQUFBLGdDQUFlLEVBQUMsUUFBUSxFQUFFLElBQUksQ0FBQyxDQUFDLENBQUM7SUFDbEYsTUFBTSxpQkFBaUIsR0FDckIsT0FBTyxDQUFDLFNBQVM7UUFDakIsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLG9CQUFvQixJQUFJLENBQUMsd0JBQXdCLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUM7SUFFL0Usd0VBQXdFO0lBQ3hFLElBQUksQ0FBQyx3QkFBd0IsSUFBSSxDQUFDLE9BQU8sQ0FBQyxxQkFBcUIsSUFBSSxDQUFDLFVBQVUsRUFBRTtRQUM5RSw4Q0FBOEM7UUFDOUMsT0FBTyxpQkFBaUIsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLG9DQUFvQyxFQUFFLEVBQUUsQ0FBQyxDQUFDO0tBQzFGO0lBRUQsOERBQThEO0lBQzlELE1BQU0sa0JBQWtCLEdBQ3RCLHFDQUFxQyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUM7UUFDcEQsQ0FBQyxxREFBcUQsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7SUFFeEUsNERBQTREO0lBQzVELElBQUksVUFBVSxFQUFFO1FBQ2QsbUJBQW1CLEtBQW5CLG1CQUFtQixHQUFLLENBQ3RCLE1BQU0sSUFBQSx3QkFBYSxFQUNqQixvQ0FBb0MsQ0FDckMsQ0FDRixDQUFDLHdCQUF3QixFQUFDO0tBQzVCO0lBRUQsTUFBTSxNQUFNLEdBQUcsTUFBTSxJQUFBLHFCQUFjLEVBQUMsSUFBSSxFQUFFO1FBQ3hDLFFBQVE7UUFDUixjQUFjLEVBQUUsQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQWM7UUFDcEUsVUFBVSxFQUFFLGlCQUFpQixDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLEtBQUs7UUFDaEQsT0FBTyxFQUFFLEtBQUs7UUFDZCxVQUFVLEVBQUUsS0FBSztRQUNqQixPQUFPLEVBQUUsS0FBSztRQUNkLHNCQUFzQixFQUFFLEtBQUs7UUFDN0IsT0FBTyxFQUFFLEVBQUU7UUFDWCxPQUFPLEVBQUU7WUFDUDtnQkFDRSxxQkFBd0I7Z0JBQ3hCO29CQUNFLGFBQWEsRUFBRSxtQkFBbUIsSUFBSTt3QkFDcEMsVUFBVTt3QkFDVixPQUFPLEVBQUUsT0FBTyxDQUFDLEdBQUc7d0JBQ3BCLG1CQUFtQjtxQkFDcEI7b0JBQ0Qsd0JBQXdCO29CQUN4QixRQUFRLEVBQUUsT0FBTyxDQUFDLHFCQUFxQixJQUFJO3dCQUN6QyxZQUFZLEVBQUUsa0JBQWtCO3FCQUNqQztpQkFDRjthQUNGO1NBQ0Y7S0FDRixDQUFDLENBQUM7SUFFSCxNQUFNLFVBQVUsR0FBRyxNQUFNLEVBQUUsSUFBSSxJQUFJLElBQUksQ0FBQztJQUV4QywrQ0FBK0M7SUFDL0MseUVBQXlFO0lBQ3pFLE9BQU8saUJBQWlCO1FBQ3RCLENBQUMsQ0FBQyxVQUFVO1FBQ1osQ0FBQyxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsb0NBQW9DLEVBQUUsRUFBRSxDQUFDLENBQUM7QUFDbkUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQgeyB0cmFuc2Zvcm1Bc3luYyB9IGZyb20gJ0BiYWJlbC9jb3JlJztcbmltcG9ydCB7IHJlYWRGaWxlIH0gZnJvbSAnbm9kZTpmcy9wcm9taXNlcyc7XG5pbXBvcnQgYW5ndWxhckFwcGxpY2F0aW9uUHJlc2V0IGZyb20gJy4uLy4uL2JhYmVsL3ByZXNldHMvYXBwbGljYXRpb24nO1xuaW1wb3J0IHsgcmVxdWlyZXNMaW5raW5nIH0gZnJvbSAnLi4vLi4vYmFiZWwvd2VicGFjay1sb2FkZXInO1xuaW1wb3J0IHsgbG9hZEVzbU1vZHVsZSB9IGZyb20gJy4uLy4uL3V0aWxzL2xvYWQtZXNtJztcblxuaW50ZXJmYWNlIEphdmFTY3JpcHRUcmFuc2Zvcm1SZXF1ZXN0IHtcbiAgZmlsZW5hbWU6IHN0cmluZztcbiAgZGF0YTogc3RyaW5nO1xuICBzb3VyY2VtYXA6IGJvb2xlYW47XG4gIHRoaXJkUGFydHlTb3VyY2VtYXBzOiBib29sZWFuO1xuICBhZHZhbmNlZE9wdGltaXphdGlvbnM6IGJvb2xlYW47XG4gIGZvcmNlQXN5bmNUcmFuc2Zvcm1hdGlvbj86IGJvb2xlYW47XG4gIHNraXBMaW5rZXI6IGJvb2xlYW47XG4gIGppdDogYm9vbGVhbjtcbn1cblxuZXhwb3J0IGRlZmF1bHQgYXN5bmMgZnVuY3Rpb24gdHJhbnNmb3JtSmF2YVNjcmlwdChcbiAgcmVxdWVzdDogSmF2YVNjcmlwdFRyYW5zZm9ybVJlcXVlc3QsXG4pOiBQcm9taXNlPFVpbnQ4QXJyYXk+IHtcbiAgcmVxdWVzdC5kYXRhID8/PSBhd2FpdCByZWFkRmlsZShyZXF1ZXN0LmZpbGVuYW1lLCAndXRmLTgnKTtcbiAgY29uc3QgdHJhbnNmb3JtZWREYXRhID0gYXdhaXQgdHJhbnNmb3JtV2l0aEJhYmVsKHJlcXVlc3QpO1xuXG4gIHJldHVybiBCdWZmZXIuZnJvbSh0cmFuc2Zvcm1lZERhdGEsICd1dGYtOCcpO1xufVxuXG5sZXQgbGlua2VyUGx1Z2luQ3JlYXRvcjpcbiAgfCB0eXBlb2YgaW1wb3J0KCdAYW5ndWxhci9jb21waWxlci1jbGkvbGlua2VyL2JhYmVsJykuY3JlYXRlRXMyMDE1TGlua2VyUGx1Z2luXG4gIHwgdW5kZWZpbmVkO1xuXG5hc3luYyBmdW5jdGlvbiB0cmFuc2Zvcm1XaXRoQmFiZWwoe1xuICBmaWxlbmFtZSxcbiAgZGF0YSxcbiAgLi4ub3B0aW9uc1xufTogSmF2YVNjcmlwdFRyYW5zZm9ybVJlcXVlc3QpOiBQcm9taXNlPHN0cmluZz4ge1xuICBjb25zdCBmb3JjZUFzeW5jVHJhbnNmb3JtYXRpb24gPVxuICAgIG9wdGlvbnMuZm9yY2VBc3luY1RyYW5zZm9ybWF0aW9uID8/XG4gICAgKCEvW1xcXFwvXVtfZl0/ZXNtMjAxNVtcXFxcL10vLnRlc3QoZmlsZW5hbWUpICYmIC9hc3luYyg/OlxccytmdW5jdGlvbik/XFxzKlxcKi8udGVzdChkYXRhKSk7XG4gIGNvbnN0IHNob3VsZExpbmsgPSAhb3B0aW9ucy5za2lwTGlua2VyICYmIChhd2FpdCByZXF1aXJlc0xpbmtpbmcoZmlsZW5hbWUsIGRhdGEpKTtcbiAgY29uc3QgdXNlSW5wdXRTb3VyY2VtYXAgPVxuICAgIG9wdGlvbnMuc291cmNlbWFwICYmXG4gICAgKCEhb3B0aW9ucy50aGlyZFBhcnR5U291cmNlbWFwcyB8fCAhL1tcXFxcL11ub2RlX21vZHVsZXNbXFxcXC9dLy50ZXN0KGZpbGVuYW1lKSk7XG5cbiAgLy8gSWYgbm8gYWRkaXRpb25hbCB0cmFuc2Zvcm1hdGlvbnMgYXJlIG5lZWRlZCwgcmV0dXJuIHRoZSBkYXRhIGRpcmVjdGx5XG4gIGlmICghZm9yY2VBc3luY1RyYW5zZm9ybWF0aW9uICYmICFvcHRpb25zLmFkdmFuY2VkT3B0aW1pemF0aW9ucyAmJiAhc2hvdWxkTGluaykge1xuICAgIC8vIFN0cmlwIHNvdXJjZW1hcHMgaWYgdGhleSBzaG91bGQgbm90IGJlIHVzZWRcbiAgICByZXR1cm4gdXNlSW5wdXRTb3VyY2VtYXAgPyBkYXRhIDogZGF0YS5yZXBsYWNlKC9eXFwvXFwvIyBzb3VyY2VNYXBwaW5nVVJMPVteXFxyXFxuXSovZ20sICcnKTtcbiAgfVxuXG4gIC8vIEBhbmd1bGFyL3BsYXRmb3JtLXNlcnZlci9pbml0IGVudHJ5LXBvaW50IGhhcyBzaWRlLWVmZmVjdHMuXG4gIGNvbnN0IHNhZmVBbmd1bGFyUGFja2FnZSA9XG4gICAgL1tcXFxcL11ub2RlX21vZHVsZXNbXFxcXC9dQGFuZ3VsYXJbXFxcXC9dLy50ZXN0KGZpbGVuYW1lKSAmJlxuICAgICEvQGFuZ3VsYXJbXFxcXC9dcGxhdGZvcm0tc2VydmVyW1xcXFwvXWY/ZXNtMjAyMltcXFxcL11pbml0Ly50ZXN0KGZpbGVuYW1lKTtcblxuICAvLyBMYXp5IGxvYWQgdGhlIGxpbmtlciBwbHVnaW4gb25seSB3aGVuIGxpbmtpbmcgaXMgcmVxdWlyZWRcbiAgaWYgKHNob3VsZExpbmspIHtcbiAgICBsaW5rZXJQbHVnaW5DcmVhdG9yID8/PSAoXG4gICAgICBhd2FpdCBsb2FkRXNtTW9kdWxlPHR5cGVvZiBpbXBvcnQoJ0Bhbmd1bGFyL2NvbXBpbGVyLWNsaS9saW5rZXIvYmFiZWwnKT4oXG4gICAgICAgICdAYW5ndWxhci9jb21waWxlci1jbGkvbGlua2VyL2JhYmVsJyxcbiAgICAgIClcbiAgICApLmNyZWF0ZUVzMjAxNUxpbmtlclBsdWdpbjtcbiAgfVxuXG4gIGNvbnN0IHJlc3VsdCA9IGF3YWl0IHRyYW5zZm9ybUFzeW5jKGRhdGEsIHtcbiAgICBmaWxlbmFtZSxcbiAgICBpbnB1dFNvdXJjZU1hcDogKHVzZUlucHV0U291cmNlbWFwID8gdW5kZWZpbmVkIDogZmFsc2UpIGFzIHVuZGVmaW5lZCxcbiAgICBzb3VyY2VNYXBzOiB1c2VJbnB1dFNvdXJjZW1hcCA/ICdpbmxpbmUnIDogZmFsc2UsXG4gICAgY29tcGFjdDogZmFsc2UsXG4gICAgY29uZmlnRmlsZTogZmFsc2UsXG4gICAgYmFiZWxyYzogZmFsc2UsXG4gICAgYnJvd3NlcnNsaXN0Q29uZmlnRmlsZTogZmFsc2UsXG4gICAgcGx1Z2luczogW10sXG4gICAgcHJlc2V0czogW1xuICAgICAgW1xuICAgICAgICBhbmd1bGFyQXBwbGljYXRpb25QcmVzZXQsXG4gICAgICAgIHtcbiAgICAgICAgICBhbmd1bGFyTGlua2VyOiBsaW5rZXJQbHVnaW5DcmVhdG9yICYmIHtcbiAgICAgICAgICAgIHNob3VsZExpbmssXG4gICAgICAgICAgICBqaXRNb2RlOiBvcHRpb25zLmppdCxcbiAgICAgICAgICAgIGxpbmtlclBsdWdpbkNyZWF0b3IsXG4gICAgICAgICAgfSxcbiAgICAgICAgICBmb3JjZUFzeW5jVHJhbnNmb3JtYXRpb24sXG4gICAgICAgICAgb3B0aW1pemU6IG9wdGlvbnMuYWR2YW5jZWRPcHRpbWl6YXRpb25zICYmIHtcbiAgICAgICAgICAgIHB1cmVUb3BMZXZlbDogc2FmZUFuZ3VsYXJQYWNrYWdlLFxuICAgICAgICAgIH0sXG4gICAgICAgIH0sXG4gICAgICBdLFxuICAgIF0sXG4gIH0pO1xuXG4gIGNvbnN0IG91dHB1dENvZGUgPSByZXN1bHQ/LmNvZGUgPz8gZGF0YTtcblxuICAvLyBTdHJpcCBzb3VyY2VtYXBzIGlmIHRoZXkgc2hvdWxkIG5vdCBiZSB1c2VkLlxuICAvLyBCYWJlbCB3aWxsIGtlZXAgdGhlIG9yaWdpbmFsIGNvbW1lbnRzIGV2ZW4gaWYgc291cmNlbWFwcyBhcmUgZGlzYWJsZWQuXG4gIHJldHVybiB1c2VJbnB1dFNvdXJjZW1hcFxuICAgID8gb3V0cHV0Q29kZVxuICAgIDogb3V0cHV0Q29kZS5yZXBsYWNlKC9eXFwvXFwvIyBzb3VyY2VNYXBwaW5nVVJMPVteXFxyXFxuXSovZ20sICcnKTtcbn1cbiJdfQ== \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/javascript-transformer.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/javascript-transformer.d.ts new file mode 100644 index 00000000..b9104e1a --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/javascript-transformer.d.ts @@ -0,0 +1,49 @@ +/** + * @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 + */ +/** + * Transformation options that should apply to all transformed files and data. + */ +export interface JavaScriptTransformerOptions { + sourcemap: boolean; + thirdPartySourcemaps?: boolean; + advancedOptimizations?: boolean; + jit?: boolean; +} +/** + * A class that performs transformation of JavaScript files and raw data. + * A worker pool is used to distribute the transformation actions and allow + * parallel processing. Transformation behavior is based on the filename and + * data. Transformations may include: async downleveling, Angular linking, + * and advanced optimizations. + */ +export declare class JavaScriptTransformer { + #private; + constructor(options: JavaScriptTransformerOptions, maxThreads?: number); + /** + * Performs JavaScript transformations on a file from the filesystem. + * If no transformations are required, the data for the original file will be returned. + * @param filename The full path to the file. + * @param skipLinker If true, bypass all Angular linker processing; if false, attempt linking. + * @returns A promise that resolves to a UTF-8 encoded Uint8Array containing the result. + */ + transformFile(filename: string, skipLinker?: boolean): Promise; + /** + * Performs JavaScript transformations on the provided data of a file. The file does not need + * to exist on the filesystem. + * @param filename The full path of the file represented by the data. + * @param data The data of the file that should be transformed. + * @param skipLinker If true, bypass all Angular linker processing; if false, attempt linking. + * @returns A promise that resolves to a UTF-8 encoded Uint8Array containing the result. + */ + transformData(filename: string, data: string, skipLinker: boolean): Promise; + /** + * Stops all active transformation tasks and shuts down all workers. + * @returns A void promise that resolves when closing is complete. + */ + close(): Promise; +} diff --git a/artifacts/build-angular/src/builders/browser-esbuild/javascript-transformer.js b/artifacts/build-angular/src/builders/browser-esbuild/javascript-transformer.js new file mode 100644 index 00000000..0bf362da --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/javascript-transformer.js @@ -0,0 +1,108 @@ +"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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) { + if (kind === "m") throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; +}; +var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +var _JavaScriptTransformer_workerPool, _JavaScriptTransformer_commonOptions; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.JavaScriptTransformer = void 0; +const piscina_1 = __importDefault(require("piscina")); +/** + * A class that performs transformation of JavaScript files and raw data. + * A worker pool is used to distribute the transformation actions and allow + * parallel processing. Transformation behavior is based on the filename and + * data. Transformations may include: async downleveling, Angular linking, + * and advanced optimizations. + */ +class JavaScriptTransformer { + constructor(options, maxThreads) { + _JavaScriptTransformer_workerPool.set(this, void 0); + _JavaScriptTransformer_commonOptions.set(this, void 0); + __classPrivateFieldSet(this, _JavaScriptTransformer_workerPool, new piscina_1.default({ + filename: require.resolve('./javascript-transformer-worker'), + maxThreads, + }), "f"); + // Extract options to ensure only the named options are serialized and sent to the worker + const { sourcemap, thirdPartySourcemaps = false, advancedOptimizations = false, jit = false, } = options; + __classPrivateFieldSet(this, _JavaScriptTransformer_commonOptions, { + sourcemap, + thirdPartySourcemaps, + advancedOptimizations, + jit, + }, "f"); + } + /** + * Performs JavaScript transformations on a file from the filesystem. + * If no transformations are required, the data for the original file will be returned. + * @param filename The full path to the file. + * @param skipLinker If true, bypass all Angular linker processing; if false, attempt linking. + * @returns A promise that resolves to a UTF-8 encoded Uint8Array containing the result. + */ + transformFile(filename, skipLinker) { + // Always send the request to a worker. Files are almost always from node modules which measn + // they may need linking. The data is also not yet available to perform most transformation checks. + return __classPrivateFieldGet(this, _JavaScriptTransformer_workerPool, "f").run({ + filename, + skipLinker, + ...__classPrivateFieldGet(this, _JavaScriptTransformer_commonOptions, "f"), + }); + } + /** + * Performs JavaScript transformations on the provided data of a file. The file does not need + * to exist on the filesystem. + * @param filename The full path of the file represented by the data. + * @param data The data of the file that should be transformed. + * @param skipLinker If true, bypass all Angular linker processing; if false, attempt linking. + * @returns A promise that resolves to a UTF-8 encoded Uint8Array containing the result. + */ + async transformData(filename, data, skipLinker) { + // Perform a quick test to determine if the data needs any transformations. + // This allows directly returning the data without the worker communication overhead. + let forceAsyncTransformation; + if (skipLinker && !__classPrivateFieldGet(this, _JavaScriptTransformer_commonOptions, "f").advancedOptimizations) { + // If the linker is being skipped and no optimizations are needed, only async transformation is left. + // This checks for async generator functions and class methods. All other async transformation is handled by esbuild. + forceAsyncTransformation = data.includes('async') && /async(?:\s+function)?\s*\*/.test(data); + if (!forceAsyncTransformation) { + const keepSourcemap = __classPrivateFieldGet(this, _JavaScriptTransformer_commonOptions, "f").sourcemap && + (!!__classPrivateFieldGet(this, _JavaScriptTransformer_commonOptions, "f").thirdPartySourcemaps || !/[\\/]node_modules[\\/]/.test(filename)); + return Buffer.from(keepSourcemap ? data : data.replace(/^\/\/# sourceMappingURL=[^\r\n]*/gm, ''), 'utf-8'); + } + } + return __classPrivateFieldGet(this, _JavaScriptTransformer_workerPool, "f").run({ + filename, + data, + // Send the async check result if present to avoid rechecking in the worker + forceAsyncTransformation, + skipLinker, + ...__classPrivateFieldGet(this, _JavaScriptTransformer_commonOptions, "f"), + }); + } + /** + * Stops all active transformation tasks and shuts down all workers. + * @returns A void promise that resolves when closing is complete. + */ + close() { + return __classPrivateFieldGet(this, _JavaScriptTransformer_workerPool, "f").destroy(); + } +} +exports.JavaScriptTransformer = JavaScriptTransformer; +_JavaScriptTransformer_workerPool = new WeakMap(), _JavaScriptTransformer_commonOptions = new WeakMap(); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"javascript-transformer.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/javascript-transformer.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;;;;;;;;;;;;;;;;AAEH,sDAA8B;AAY9B;;;;;;GAMG;AACH,MAAa,qBAAqB;IAIhC,YAAY,OAAqC,EAAE,UAAmB;QAHtE,oDAAqB;QACrB,uDAAuD;QAGrD,uBAAA,IAAI,qCAAe,IAAI,iBAAO,CAAC;YAC7B,QAAQ,EAAE,OAAO,CAAC,OAAO,CAAC,iCAAiC,CAAC;YAC5D,UAAU;SACX,CAAC,MAAA,CAAC;QAEH,yFAAyF;QACzF,MAAM,EACJ,SAAS,EACT,oBAAoB,GAAG,KAAK,EAC5B,qBAAqB,GAAG,KAAK,EAC7B,GAAG,GAAG,KAAK,GACZ,GAAG,OAAO,CAAC;QACZ,uBAAA,IAAI,wCAAkB;YACpB,SAAS;YACT,oBAAoB;YACpB,qBAAqB;YACrB,GAAG;SACJ,MAAA,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,aAAa,CAAC,QAAgB,EAAE,UAAoB;QAClD,6FAA6F;QAC7F,mGAAmG;QACnG,OAAO,uBAAA,IAAI,yCAAY,CAAC,GAAG,CAAC;YAC1B,QAAQ;YACR,UAAU;YACV,GAAG,uBAAA,IAAI,4CAAe;SACvB,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,aAAa,CAAC,QAAgB,EAAE,IAAY,EAAE,UAAmB;QACrE,2EAA2E;QAC3E,qFAAqF;QACrF,IAAI,wBAAwB,CAAC;QAC7B,IAAI,UAAU,IAAI,CAAC,uBAAA,IAAI,4CAAe,CAAC,qBAAqB,EAAE;YAC5D,qGAAqG;YACrG,qHAAqH;YACrH,wBAAwB,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,4BAA4B,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAE7F,IAAI,CAAC,wBAAwB,EAAE;gBAC7B,MAAM,aAAa,GACjB,uBAAA,IAAI,4CAAe,CAAC,SAAS;oBAC7B,CAAC,CAAC,CAAC,uBAAA,IAAI,4CAAe,CAAC,oBAAoB,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;gBAE3F,OAAO,MAAM,CAAC,IAAI,CAChB,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,oCAAoC,EAAE,EAAE,CAAC,EAC7E,OAAO,CACR,CAAC;aACH;SACF;QAED,OAAO,uBAAA,IAAI,yCAAY,CAAC,GAAG,CAAC;YAC1B,QAAQ;YACR,IAAI;YACJ,2EAA2E;YAC3E,wBAAwB;YACxB,UAAU;YACV,GAAG,uBAAA,IAAI,4CAAe;SACvB,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACH,KAAK;QACH,OAAO,uBAAA,IAAI,yCAAY,CAAC,OAAO,EAAE,CAAC;IACpC,CAAC;CACF;AAxFD,sDAwFC","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 Piscina from 'piscina';\n\n/**\n * Transformation options that should apply to all transformed files and data.\n */\nexport interface JavaScriptTransformerOptions {\n  sourcemap: boolean;\n  thirdPartySourcemaps?: boolean;\n  advancedOptimizations?: boolean;\n  jit?: boolean;\n}\n\n/**\n * A class that performs transformation of JavaScript files and raw data.\n * A worker pool is used to distribute the transformation actions and allow\n * parallel processing. Transformation behavior is based on the filename and\n * data. Transformations may include: async downleveling, Angular linking,\n * and advanced optimizations.\n */\nexport class JavaScriptTransformer {\n  #workerPool: Piscina;\n  #commonOptions: Required<JavaScriptTransformerOptions>;\n\n  constructor(options: JavaScriptTransformerOptions, maxThreads?: number) {\n    this.#workerPool = new Piscina({\n      filename: require.resolve('./javascript-transformer-worker'),\n      maxThreads,\n    });\n\n    // Extract options to ensure only the named options are serialized and sent to the worker\n    const {\n      sourcemap,\n      thirdPartySourcemaps = false,\n      advancedOptimizations = false,\n      jit = false,\n    } = options;\n    this.#commonOptions = {\n      sourcemap,\n      thirdPartySourcemaps,\n      advancedOptimizations,\n      jit,\n    };\n  }\n\n  /**\n   * Performs JavaScript transformations on a file from the filesystem.\n   * If no transformations are required, the data for the original file will be returned.\n   * @param filename The full path to the file.\n   * @param skipLinker If true, bypass all Angular linker processing; if false, attempt linking.\n   * @returns A promise that resolves to a UTF-8 encoded Uint8Array containing the result.\n   */\n  transformFile(filename: string, skipLinker?: boolean): Promise<Uint8Array> {\n    // Always send the request to a worker. Files are almost always from node modules which measn\n    // they may need linking. The data is also not yet available to perform most transformation checks.\n    return this.#workerPool.run({\n      filename,\n      skipLinker,\n      ...this.#commonOptions,\n    });\n  }\n\n  /**\n   * Performs JavaScript transformations on the provided data of a file. The file does not need\n   * to exist on the filesystem.\n   * @param filename The full path of the file represented by the data.\n   * @param data The data of the file that should be transformed.\n   * @param skipLinker If true, bypass all Angular linker processing; if false, attempt linking.\n   * @returns A promise that resolves to a UTF-8 encoded Uint8Array containing the result.\n   */\n  async transformData(filename: string, data: string, skipLinker: boolean): Promise<Uint8Array> {\n    // Perform a quick test to determine if the data needs any transformations.\n    // This allows directly returning the data without the worker communication overhead.\n    let forceAsyncTransformation;\n    if (skipLinker && !this.#commonOptions.advancedOptimizations) {\n      // If the linker is being skipped and no optimizations are needed, only async transformation is left.\n      // This checks for async generator functions and class methods. All other async transformation is handled by esbuild.\n      forceAsyncTransformation = data.includes('async') && /async(?:\\s+function)?\\s*\\*/.test(data);\n\n      if (!forceAsyncTransformation) {\n        const keepSourcemap =\n          this.#commonOptions.sourcemap &&\n          (!!this.#commonOptions.thirdPartySourcemaps || !/[\\\\/]node_modules[\\\\/]/.test(filename));\n\n        return Buffer.from(\n          keepSourcemap ? data : data.replace(/^\\/\\/# sourceMappingURL=[^\\r\\n]*/gm, ''),\n          'utf-8',\n        );\n      }\n    }\n\n    return this.#workerPool.run({\n      filename,\n      data,\n      // Send the async check result if present to avoid rechecking in the worker\n      forceAsyncTransformation,\n      skipLinker,\n      ...this.#commonOptions,\n    });\n  }\n\n  /**\n   * Stops all active transformation tasks and shuts down all workers.\n   * @returns A void promise that resolves when closing is complete.\n   */\n  close(): Promise<void> {\n    return this.#workerPool.destroy();\n  }\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/license-extractor.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/license-extractor.d.ts new file mode 100644 index 00000000..b50baa7a --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/license-extractor.d.ts @@ -0,0 +1,25 @@ +/** + * @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 type { Metafile } from 'esbuild'; +/** + * Extracts license information for each node module package included in the output + * files of the built code. This includes JavaScript and CSS output files. The esbuild + * metafile generated during the bundling steps is used as the source of information + * regarding what input files where included and where they are located. A path segment + * of `node_modules` is used to indicate that a file belongs to a package and its license + * should be include in the output licenses file. + * + * The package name and license field are extracted from the `package.json` file for the + * package. If a license file (e.g., `LICENSE`) is present in the root of the package, it + * will also be included in the output licenses file. + * + * @param metafile An esbuild metafile object. + * @param rootDirectory The root directory of the workspace. + * @returns A string containing the content of the output licenses file. + */ +export declare function extractLicenses(metafile: Metafile, rootDirectory: string): Promise; diff --git a/artifacts/build-angular/src/builders/browser-esbuild/license-extractor.js b/artifacts/build-angular/src/builders/browser-esbuild/license-extractor.js new file mode 100644 index 00000000..7ca8308c --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/license-extractor.js @@ -0,0 +1,159 @@ +"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 __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.extractLicenses = void 0; +const promises_1 = require("node:fs/promises"); +const node_path_1 = __importDefault(require("node:path")); +/** + * The path segment used to signify that a file is part of a package. + */ +const NODE_MODULE_SEGMENT = 'node_modules'; +/** + * String constant for the NPM recommended custom license wording. + * + * See: https://docs.npmjs.com/cli/v9/configuring-npm/package-json#license + * + * Example: + * ``` + * { + * "license" : "SEE LICENSE IN " + * } + * ``` + */ +const CUSTOM_LICENSE_TEXT = 'SEE LICENSE IN '; +/** + * A list of commonly named license files found within packages. + */ +const LICENSE_FILES = ['LICENSE', 'LICENSE.txt', 'LICENSE.md']; +/** + * Header text that will be added to the top of the output license extraction file. + */ +const EXTRACTION_FILE_HEADER = ''; +/** + * The package entry separator to use within the output license extraction file. + */ +const EXTRACTION_FILE_SEPARATOR = '-'.repeat(80) + '\n'; +/** + * Extracts license information for each node module package included in the output + * files of the built code. This includes JavaScript and CSS output files. The esbuild + * metafile generated during the bundling steps is used as the source of information + * regarding what input files where included and where they are located. A path segment + * of `node_modules` is used to indicate that a file belongs to a package and its license + * should be include in the output licenses file. + * + * The package name and license field are extracted from the `package.json` file for the + * package. If a license file (e.g., `LICENSE`) is present in the root of the package, it + * will also be included in the output licenses file. + * + * @param metafile An esbuild metafile object. + * @param rootDirectory The root directory of the workspace. + * @returns A string containing the content of the output licenses file. + */ +async function extractLicenses(metafile, rootDirectory) { + let extractedLicenseContent = `${EXTRACTION_FILE_HEADER}\n${EXTRACTION_FILE_SEPARATOR}`; + const seenPaths = new Set(); + const seenPackages = new Set(); + for (const entry of Object.values(metafile.outputs)) { + for (const [inputPath, { bytesInOutput }] of Object.entries(entry.inputs)) { + // Skip if not included in output + if (bytesInOutput <= 0) { + continue; + } + // Skip already processed paths + if (seenPaths.has(inputPath)) { + continue; + } + seenPaths.add(inputPath); + // Skip non-package paths + if (!inputPath.includes(NODE_MODULE_SEGMENT)) { + continue; + } + // Extract the package name from the path + let baseDirectory = node_path_1.default.join(rootDirectory, inputPath); + let nameOrScope, nameOrFile; + let found = false; + while (baseDirectory !== node_path_1.default.dirname(baseDirectory)) { + const segment = node_path_1.default.basename(baseDirectory); + if (segment === NODE_MODULE_SEGMENT) { + found = true; + break; + } + nameOrFile = nameOrScope; + nameOrScope = segment; + baseDirectory = node_path_1.default.dirname(baseDirectory); + } + // Skip non-package path edge cases that are not caught in the includes check above + if (!found || !nameOrScope) { + continue; + } + const packageName = nameOrScope.startsWith('@') + ? `${nameOrScope}/${nameOrFile}` + : nameOrScope; + const packageDirectory = node_path_1.default.join(baseDirectory, packageName); + // Load the package's metadata to find the package's name, version, and license type + const packageJsonPath = node_path_1.default.join(packageDirectory, 'package.json'); + let packageJson; + try { + packageJson = JSON.parse(await (0, promises_1.readFile)(packageJsonPath, 'utf-8')); + } + catch { + // Invalid package + continue; + } + // Skip already processed packages + const packageId = `${packageName}@${packageJson.version}`; + if (seenPackages.has(packageId)) { + continue; + } + seenPackages.add(packageId); + // Attempt to find license text inside package + let licenseText = ''; + if (typeof packageJson.license === 'string' && + packageJson.license.toLowerCase().startsWith(CUSTOM_LICENSE_TEXT)) { + // Attempt to load the package's custom license + let customLicensePath; + const customLicenseFile = node_path_1.default.normalize(packageJson.license.slice(CUSTOM_LICENSE_TEXT.length + 1).trim()); + if (customLicenseFile.startsWith('..') || node_path_1.default.isAbsolute(customLicenseFile)) { + // Path is attempting to access files outside of the package + // TODO: Issue warning? + } + else { + customLicensePath = node_path_1.default.join(packageDirectory, customLicenseFile); + try { + licenseText = await (0, promises_1.readFile)(customLicensePath, 'utf-8'); + break; + } + catch { } + } + } + else { + // Search for a license file within the root of the package + for (const potentialLicense of LICENSE_FILES) { + const packageLicensePath = node_path_1.default.join(packageDirectory, potentialLicense); + try { + licenseText = await (0, promises_1.readFile)(packageLicensePath, 'utf-8'); + break; + } + catch { } + } + } + // Generate the package's license entry in the output content + extractedLicenseContent += `Package: ${packageJson.name}\n`; + extractedLicenseContent += `License: ${JSON.stringify(packageJson.license, null, 2)}\n`; + extractedLicenseContent += `\n${licenseText}\n`; + extractedLicenseContent += EXTRACTION_FILE_SEPARATOR; + } + } + return extractedLicenseContent; +} +exports.extractLicenses = extractLicenses; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"license-extractor.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/license-extractor.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;;;;AAGH,+CAA4C;AAC5C,0DAA6B;AAE7B;;GAEG;AACH,MAAM,mBAAmB,GAAG,cAAc,CAAC;AAE3C;;;;;;;;;;;GAWG;AACH,MAAM,mBAAmB,GAAG,iBAAiB,CAAC;AAE9C;;GAEG;AACH,MAAM,aAAa,GAAG,CAAC,SAAS,EAAE,aAAa,EAAE,YAAY,CAAC,CAAC;AAE/D;;GAEG;AACH,MAAM,sBAAsB,GAAG,EAAE,CAAC;AAElC;;GAEG;AACH,MAAM,yBAAyB,GAAG,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC;AAExD;;;;;;;;;;;;;;;GAeG;AACI,KAAK,UAAU,eAAe,CAAC,QAAkB,EAAE,aAAqB;IAC7E,IAAI,uBAAuB,GAAG,GAAG,sBAAsB,KAAK,yBAAyB,EAAE,CAAC;IAExF,MAAM,SAAS,GAAG,IAAI,GAAG,EAAU,CAAC;IACpC,MAAM,YAAY,GAAG,IAAI,GAAG,EAAU,CAAC;IAEvC,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE;QACnD,KAAK,MAAM,CAAC,SAAS,EAAE,EAAE,aAAa,EAAE,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;YACzE,iCAAiC;YACjC,IAAI,aAAa,IAAI,CAAC,EAAE;gBACtB,SAAS;aACV;YAED,+BAA+B;YAC/B,IAAI,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE;gBAC5B,SAAS;aACV;YACD,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YAEzB,yBAAyB;YACzB,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,mBAAmB,CAAC,EAAE;gBAC5C,SAAS;aACV;YAED,yCAAyC;YACzC,IAAI,aAAa,GAAG,mBAAI,CAAC,IAAI,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC;YACxD,IAAI,WAAW,EAAE,UAAU,CAAC;YAC5B,IAAI,KAAK,GAAG,KAAK,CAAC;YAClB,OAAO,aAAa,KAAK,mBAAI,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE;gBACpD,MAAM,OAAO,GAAG,mBAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;gBAC7C,IAAI,OAAO,KAAK,mBAAmB,EAAE;oBACnC,KAAK,GAAG,IAAI,CAAC;oBACb,MAAM;iBACP;gBAED,UAAU,GAAG,WAAW,CAAC;gBACzB,WAAW,GAAG,OAAO,CAAC;gBACtB,aAAa,GAAG,mBAAI,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;aAC7C;YAED,mFAAmF;YACnF,IAAI,CAAC,KAAK,IAAI,CAAC,WAAW,EAAE;gBAC1B,SAAS;aACV;YAED,MAAM,WAAW,GAAG,WAAW,CAAC,UAAU,CAAC,GAAG,CAAC;gBAC7C,CAAC,CAAC,GAAG,WAAW,IAAI,UAAU,EAAE;gBAChC,CAAC,CAAC,WAAW,CAAC;YAChB,MAAM,gBAAgB,GAAG,mBAAI,CAAC,IAAI,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC;YAE/D,oFAAoF;YACpF,MAAM,eAAe,GAAG,mBAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,cAAc,CAAC,CAAC;YACpE,IAAI,WAAW,CAAC;YAChB,IAAI;gBACF,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,IAAA,mBAAQ,EAAC,eAAe,EAAE,OAAO,CAAC,CAKhE,CAAC;aACH;YAAC,MAAM;gBACN,kBAAkB;gBAClB,SAAS;aACV;YAED,kCAAkC;YAClC,MAAM,SAAS,GAAG,GAAG,WAAW,IAAI,WAAW,CAAC,OAAO,EAAE,CAAC;YAC1D,IAAI,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE;gBAC/B,SAAS;aACV;YACD,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YAE5B,8CAA8C;YAC9C,IAAI,WAAW,GAAG,EAAE,CAAC;YACrB,IACE,OAAO,WAAW,CAAC,OAAO,KAAK,QAAQ;gBACvC,WAAW,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,mBAAmB,CAAC,EACjE;gBACA,+CAA+C;gBAC/C,IAAI,iBAAiB,CAAC;gBACtB,MAAM,iBAAiB,GAAG,mBAAI,CAAC,SAAS,CACtC,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,mBAAmB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,CACjE,CAAC;gBACF,IAAI,iBAAiB,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,mBAAI,CAAC,UAAU,CAAC,iBAAiB,CAAC,EAAE;oBAC5E,4DAA4D;oBAC5D,uBAAuB;iBACxB;qBAAM;oBACL,iBAAiB,GAAG,mBAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAAC;oBACnE,IAAI;wBACF,WAAW,GAAG,MAAM,IAAA,mBAAQ,EAAC,iBAAiB,EAAE,OAAO,CAAC,CAAC;wBACzD,MAAM;qBACP;oBAAC,MAAM,GAAE;iBACX;aACF;iBAAM;gBACL,2DAA2D;gBAC3D,KAAK,MAAM,gBAAgB,IAAI,aAAa,EAAE;oBAC5C,MAAM,kBAAkB,GAAG,mBAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,CAAC;oBACzE,IAAI;wBACF,WAAW,GAAG,MAAM,IAAA,mBAAQ,EAAC,kBAAkB,EAAE,OAAO,CAAC,CAAC;wBAC1D,MAAM;qBACP;oBAAC,MAAM,GAAE;iBACX;aACF;YAED,6DAA6D;YAC7D,uBAAuB,IAAI,YAAY,WAAW,CAAC,IAAI,IAAI,CAAC;YAC5D,uBAAuB,IAAI,YAAY,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC;YACxF,uBAAuB,IAAI,KAAK,WAAW,IAAI,CAAC;YAChD,uBAAuB,IAAI,yBAAyB,CAAC;SACtD;KACF;IAED,OAAO,uBAAuB,CAAC;AACjC,CAAC;AAjHD,0CAiHC","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 type { Metafile } from 'esbuild';\nimport { readFile } from 'node:fs/promises';\nimport path from 'node:path';\n\n/**\n * The path segment used to signify that a file is part of a package.\n */\nconst NODE_MODULE_SEGMENT = 'node_modules';\n\n/**\n * String constant for the NPM recommended custom license wording.\n *\n * See: https://docs.npmjs.com/cli/v9/configuring-npm/package-json#license\n *\n * Example:\n * ```\n * {\n *   \"license\" : \"SEE LICENSE IN <filename>\"\n * }\n * ```\n */\nconst CUSTOM_LICENSE_TEXT = 'SEE LICENSE IN ';\n\n/**\n * A list of commonly named license files found within packages.\n */\nconst LICENSE_FILES = ['LICENSE', 'LICENSE.txt', 'LICENSE.md'];\n\n/**\n * Header text that will be added to the top of the output license extraction file.\n */\nconst EXTRACTION_FILE_HEADER = '';\n\n/**\n * The package entry separator to use within the output license extraction file.\n */\nconst EXTRACTION_FILE_SEPARATOR = '-'.repeat(80) + '\\n';\n\n/**\n * Extracts license information for each node module package included in the output\n * files of the built code. This includes JavaScript and CSS output files. The esbuild\n * metafile generated during the bundling steps is used as the source of information\n * regarding what input files where included and where they are located. A path segment\n * of `node_modules` is used to indicate that a file belongs to a package and its license\n * should be include in the output licenses file.\n *\n * The package name and license field are extracted from the `package.json` file for the\n * package. If a license file (e.g., `LICENSE`) is present in the root of the package, it\n * will also be included in the output licenses file.\n *\n * @param metafile An esbuild metafile object.\n * @param rootDirectory The root directory of the workspace.\n * @returns A string containing the content of the output licenses file.\n */\nexport async function extractLicenses(metafile: Metafile, rootDirectory: string) {\n  let extractedLicenseContent = `${EXTRACTION_FILE_HEADER}\\n${EXTRACTION_FILE_SEPARATOR}`;\n\n  const seenPaths = new Set<string>();\n  const seenPackages = new Set<string>();\n\n  for (const entry of Object.values(metafile.outputs)) {\n    for (const [inputPath, { bytesInOutput }] of Object.entries(entry.inputs)) {\n      // Skip if not included in output\n      if (bytesInOutput <= 0) {\n        continue;\n      }\n\n      // Skip already processed paths\n      if (seenPaths.has(inputPath)) {\n        continue;\n      }\n      seenPaths.add(inputPath);\n\n      // Skip non-package paths\n      if (!inputPath.includes(NODE_MODULE_SEGMENT)) {\n        continue;\n      }\n\n      // Extract the package name from the path\n      let baseDirectory = path.join(rootDirectory, inputPath);\n      let nameOrScope, nameOrFile;\n      let found = false;\n      while (baseDirectory !== path.dirname(baseDirectory)) {\n        const segment = path.basename(baseDirectory);\n        if (segment === NODE_MODULE_SEGMENT) {\n          found = true;\n          break;\n        }\n\n        nameOrFile = nameOrScope;\n        nameOrScope = segment;\n        baseDirectory = path.dirname(baseDirectory);\n      }\n\n      // Skip non-package path edge cases that are not caught in the includes check above\n      if (!found || !nameOrScope) {\n        continue;\n      }\n\n      const packageName = nameOrScope.startsWith('@')\n        ? `${nameOrScope}/${nameOrFile}`\n        : nameOrScope;\n      const packageDirectory = path.join(baseDirectory, packageName);\n\n      // Load the package's metadata to find the package's name, version, and license type\n      const packageJsonPath = path.join(packageDirectory, 'package.json');\n      let packageJson;\n      try {\n        packageJson = JSON.parse(await readFile(packageJsonPath, 'utf-8')) as {\n          name: string;\n          version: string;\n          // The object form is deprecated and should only be present in old packages\n          license?: string | { type: string };\n        };\n      } catch {\n        // Invalid package\n        continue;\n      }\n\n      // Skip already processed packages\n      const packageId = `${packageName}@${packageJson.version}`;\n      if (seenPackages.has(packageId)) {\n        continue;\n      }\n      seenPackages.add(packageId);\n\n      // Attempt to find license text inside package\n      let licenseText = '';\n      if (\n        typeof packageJson.license === 'string' &&\n        packageJson.license.toLowerCase().startsWith(CUSTOM_LICENSE_TEXT)\n      ) {\n        // Attempt to load the package's custom license\n        let customLicensePath;\n        const customLicenseFile = path.normalize(\n          packageJson.license.slice(CUSTOM_LICENSE_TEXT.length + 1).trim(),\n        );\n        if (customLicenseFile.startsWith('..') || path.isAbsolute(customLicenseFile)) {\n          // Path is attempting to access files outside of the package\n          // TODO: Issue warning?\n        } else {\n          customLicensePath = path.join(packageDirectory, customLicenseFile);\n          try {\n            licenseText = await readFile(customLicensePath, 'utf-8');\n            break;\n          } catch {}\n        }\n      } else {\n        // Search for a license file within the root of the package\n        for (const potentialLicense of LICENSE_FILES) {\n          const packageLicensePath = path.join(packageDirectory, potentialLicense);\n          try {\n            licenseText = await readFile(packageLicensePath, 'utf-8');\n            break;\n          } catch {}\n        }\n      }\n\n      // Generate the package's license entry in the output content\n      extractedLicenseContent += `Package: ${packageJson.name}\\n`;\n      extractedLicenseContent += `License: ${JSON.stringify(packageJson.license, null, 2)}\\n`;\n      extractedLicenseContent += `\\n${licenseText}\\n`;\n      extractedLicenseContent += EXTRACTION_FILE_SEPARATOR;\n    }\n  }\n\n  return extractedLicenseContent;\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/load-result-cache.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/load-result-cache.d.ts new file mode 100644 index 00000000..05b77aad --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/load-result-cache.d.ts @@ -0,0 +1,18 @@ +/** + * @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 type { OnLoadResult } from 'esbuild'; +export interface LoadResultCache { + get(path: string): OnLoadResult | undefined; + put(path: string, result: OnLoadResult): Promise; +} +export declare class MemoryLoadResultCache implements LoadResultCache { + #private; + get(path: string): OnLoadResult | undefined; + put(path: string, result: OnLoadResult): Promise; + invalidate(path: string): boolean; +} diff --git a/artifacts/build-angular/src/builders/browser-esbuild/load-result-cache.js b/artifacts/build-angular/src/builders/browser-esbuild/load-result-cache.js new file mode 100644 index 00000000..7f09424e --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/load-result-cache.js @@ -0,0 +1,51 @@ +"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 __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +}; +var _MemoryLoadResultCache_loadResults, _MemoryLoadResultCache_fileDependencies; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.MemoryLoadResultCache = void 0; +class MemoryLoadResultCache { + constructor() { + _MemoryLoadResultCache_loadResults.set(this, new Map()); + _MemoryLoadResultCache_fileDependencies.set(this, new Map()); + } + get(path) { + return __classPrivateFieldGet(this, _MemoryLoadResultCache_loadResults, "f").get(path); + } + async put(path, result) { + __classPrivateFieldGet(this, _MemoryLoadResultCache_loadResults, "f").set(path, result); + if (result.watchFiles) { + for (const watchFile of result.watchFiles) { + let affected = __classPrivateFieldGet(this, _MemoryLoadResultCache_fileDependencies, "f").get(watchFile); + if (affected === undefined) { + affected = new Set(); + __classPrivateFieldGet(this, _MemoryLoadResultCache_fileDependencies, "f").set(watchFile, affected); + } + affected.add(path); + } + } + } + invalidate(path) { + const affected = __classPrivateFieldGet(this, _MemoryLoadResultCache_fileDependencies, "f").get(path); + let found = false; + if (affected) { + affected.forEach((a) => (found || (found = __classPrivateFieldGet(this, _MemoryLoadResultCache_loadResults, "f").delete(a)))); + __classPrivateFieldGet(this, _MemoryLoadResultCache_fileDependencies, "f").delete(path); + } + found || (found = __classPrivateFieldGet(this, _MemoryLoadResultCache_loadResults, "f").delete(path)); + return found; + } +} +exports.MemoryLoadResultCache = MemoryLoadResultCache; +_MemoryLoadResultCache_loadResults = new WeakMap(), _MemoryLoadResultCache_fileDependencies = new WeakMap(); +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/options.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/options.d.ts new file mode 100644 index 00000000..b68aa3e0 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/options.d.ts @@ -0,0 +1,91 @@ +/** + * @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 { Schema as BrowserBuilderOptions } from './schema'; +export type NormalizedBrowserOptions = Awaited>; +/** Internal options hidden from builder schema but available when invoked programmatically. */ +interface InternalOptions { + /** + * Entry points to use for the compilation. Incompatible with `main`, which must not be provided. May be relative or absolute paths. + * If given a relative path, it is resolved relative to the current workspace and will generate an output at the same relative location + * in the output directory. If given an absolute path, the output will be generated in the root of the output directory with the same base + * name. + */ + entryPoints?: Set; + /** File extension to use for the generated output files. */ + outExtension?: 'js' | 'mjs'; +} +/** Full set of options for `browser-esbuild` builder. */ +export type BrowserEsbuildOptions = Omit & { + main?: string; +}; +/** + * Normalize the user provided options by creating full paths for all path based options + * and converting multi-form options into a single form that can be directly used + * by the build process. + * + * @param context The context for current builder execution. + * @param projectName The name of the project for the current execution. + * @param options An object containing the options to use for the build. + * @returns An object containing normalized options required to perform the build. + */ +export declare function normalizeOptions(context: BuilderContext, projectName: string, options: BrowserEsbuildOptions): Promise<{ + advancedOptimizations: boolean | undefined; + allowedCommonJsDependencies: string[] | undefined; + baseHref: string | undefined; + cacheOptions: import("../../utils/normalize-cache").NormalizedCachedOptions; + crossOrigin: import("./schema").CrossOrigin | undefined; + externalDependencies: string[] | undefined; + extractLicenses: boolean | undefined; + inlineStyleLanguage: string; + jit: boolean; + stats: boolean; + polyfills: string[] | undefined; + poll: number | undefined; + progress: boolean; + preserveSymlinks: boolean; + stylePreprocessorOptions: import("./schema").StylePreprocessorOptions | undefined; + subresourceIntegrity: boolean | undefined; + verbose: boolean | undefined; + watch: boolean | undefined; + workspaceRoot: string; + entryPoints: Record; + optimizationOptions: import("../../utils").NormalizedOptimizationOptions; + outputPath: string; + outExtension: "js" | "mjs" | undefined; + sourcemapOptions: import("../..").SourceMapObject; + tsconfig: string; + projectRoot: string; + assets: import("../..").AssetPatternObject[] | undefined; + outputNames: { + bundles: string; + media: string; + }; + fileReplacements: Record | undefined; + globalStyles: { + name: string; + files: string[]; + initial: boolean; + }[]; + globalScripts: { + name: string; + files: string[]; + initial: boolean; + }[]; + serviceWorkerOptions: string | undefined; + indexHtmlOptions: { + input: string; + output: string; + insertionOrder: import("../../utils/package-chunk-sort").EntryPointsType[]; + } | undefined; + tailwindConfiguration: { + file: string; + package: string; + } | undefined; +}>; +export {}; diff --git a/artifacts/build-angular/src/builders/browser-esbuild/options.js b/artifacts/build-angular/src/builders/browser-esbuild/options.js new file mode 100644 index 00000000..e9fab22c --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/options.js @@ -0,0 +1,227 @@ +"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 __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.normalizeOptions = void 0; +const node_module_1 = require("node:module"); +const node_path_1 = __importDefault(require("node:path")); +const utils_1 = require("../../utils"); +const normalize_cache_1 = require("../../utils/normalize-cache"); +const package_chunk_sort_1 = require("../../utils/package-chunk-sort"); +const tailwind_1 = require("../../utils/tailwind"); +const webpack_browser_config_1 = require("../../utils/webpack-browser-config"); +const helpers_1 = require("../../webpack/utils/helpers"); +const schema_1 = require("./schema"); +/** + * Normalize the user provided options by creating full paths for all path based options + * and converting multi-form options into a single form that can be directly used + * by the build process. + * + * @param context The context for current builder execution. + * @param projectName The name of the project for the current execution. + * @param options An object containing the options to use for the build. + * @returns An object containing normalized options required to perform the build. + */ +async function normalizeOptions(context, projectName, options) { + const workspaceRoot = context.workspaceRoot; + const projectMetadata = await context.getProjectMetadata(projectName); + const projectRoot = normalizeDirectoryPath(node_path_1.default.join(workspaceRoot, projectMetadata.root ?? '')); + const projectSourceRoot = normalizeDirectoryPath(node_path_1.default.join(workspaceRoot, projectMetadata.sourceRoot ?? 'src')); + const cacheOptions = (0, normalize_cache_1.normalizeCacheOptions)(projectMetadata, workspaceRoot); + const entryPoints = normalizeEntryPoints(workspaceRoot, options.main, options.entryPoints); + const tsconfig = node_path_1.default.join(workspaceRoot, options.tsConfig); + const outputPath = normalizeDirectoryPath(node_path_1.default.join(workspaceRoot, options.outputPath)); + const optimizationOptions = (0, utils_1.normalizeOptimization)(options.optimization); + const sourcemapOptions = (0, utils_1.normalizeSourceMaps)(options.sourceMap ?? false); + const assets = options.assets?.length + ? (0, utils_1.normalizeAssetPatterns)(options.assets, workspaceRoot, projectRoot, projectSourceRoot) + : undefined; + const outputNames = { + bundles: options.outputHashing === schema_1.OutputHashing.All || options.outputHashing === schema_1.OutputHashing.Bundles + ? '[name].[hash]' + : '[name]', + media: options.outputHashing === schema_1.OutputHashing.All || options.outputHashing === schema_1.OutputHashing.Media + ? '[name].[hash]' + : '[name]', + }; + if (options.resourcesOutputPath) { + outputNames.media = node_path_1.default.join(options.resourcesOutputPath, outputNames.media); + } + let fileReplacements; + if (options.fileReplacements) { + for (const replacement of options.fileReplacements) { + fileReplacements ?? (fileReplacements = {}); + fileReplacements[node_path_1.default.join(workspaceRoot, replacement.replace)] = node_path_1.default.join(workspaceRoot, replacement.with); + } + } + const globalStyles = []; + if (options.styles?.length) { + const { entryPoints: stylesheetEntrypoints, noInjectNames } = (0, helpers_1.normalizeGlobalStyles)(options.styles || []); + for (const [name, files] of Object.entries(stylesheetEntrypoints)) { + globalStyles.push({ name, files, initial: !noInjectNames.includes(name) }); + } + } + const globalScripts = []; + if (options.scripts?.length) { + for (const { bundleName, paths, inject } of (0, helpers_1.globalScriptsByBundleName)(options.scripts)) { + globalScripts.push({ name: bundleName, files: paths, initial: inject }); + } + } + let tailwindConfiguration; + const tailwindConfigurationPath = await (0, tailwind_1.findTailwindConfigurationFile)(workspaceRoot, projectRoot); + if (tailwindConfigurationPath) { + // Create a node resolver at the project root as a directory + const resolver = (0, node_module_1.createRequire)(projectRoot + '/'); + try { + tailwindConfiguration = { + file: tailwindConfigurationPath, + package: resolver.resolve('tailwindcss'), + }; + } + catch { + const relativeTailwindConfigPath = node_path_1.default.relative(workspaceRoot, tailwindConfigurationPath); + context.logger.warn(`Tailwind CSS configuration file found (${relativeTailwindConfigPath})` + + ` but the 'tailwindcss' package is not installed.` + + ` To enable Tailwind CSS, please install the 'tailwindcss' package.`); + } + } + let serviceWorkerOptions; + if (options.serviceWorker) { + // If ngswConfigPath is not specified, the default is 'ngsw-config.json' within the project root + serviceWorkerOptions = options.ngswConfigPath + ? node_path_1.default.join(workspaceRoot, options.ngswConfigPath) + : node_path_1.default.join(projectRoot, 'ngsw-config.json'); + } + let indexHtmlOptions; + if (options.index) { + indexHtmlOptions = { + input: node_path_1.default.join(workspaceRoot, (0, webpack_browser_config_1.getIndexInputFile)(options.index)), + // The output file will be created within the configured output path + output: (0, webpack_browser_config_1.getIndexOutputFile)(options.index), + // TODO: Use existing information from above to create the insertion order + insertionOrder: (0, package_chunk_sort_1.generateEntryPoints)({ + scripts: options.scripts ?? [], + styles: options.styles ?? [], + }), + }; + } + // Initial options to keep + const { allowedCommonJsDependencies, aot, baseHref, buildOptimizer, crossOrigin, externalDependencies, extractLicenses, inlineStyleLanguage = 'css', outExtension, poll, polyfills, preserveSymlinks, statsJson, stylePreprocessorOptions, subresourceIntegrity, verbose, watch, progress, } = options; + // Return all the normalized options + return { + advancedOptimizations: buildOptimizer, + allowedCommonJsDependencies, + baseHref, + cacheOptions, + crossOrigin, + externalDependencies, + extractLicenses, + inlineStyleLanguage, + jit: !aot, + stats: !!statsJson, + polyfills: polyfills === undefined || Array.isArray(polyfills) ? polyfills : [polyfills], + poll, + progress: progress ?? true, + // If not explicitly set, default to the Node.js process argument + preserveSymlinks: preserveSymlinks ?? process.execArgv.includes('--preserve-symlinks'), + stylePreprocessorOptions, + subresourceIntegrity, + verbose, + watch, + workspaceRoot, + entryPoints, + optimizationOptions, + outputPath, + outExtension, + sourcemapOptions, + tsconfig, + projectRoot, + assets, + outputNames, + fileReplacements, + globalStyles, + globalScripts, + serviceWorkerOptions, + indexHtmlOptions, + tailwindConfiguration, + }; +} +exports.normalizeOptions = normalizeOptions; +/** + * Normalize entry point options. To maintain compatibility with the legacy browser builder, we need a single `main` option which defines a + * single entry point. However, we also want to support multiple entry points as an internal option. The two options are mutually exclusive + * and if `main` is provided it will be used as the sole entry point. If `entryPoints` are provided, they will be used as the set of entry + * points. + * + * @param workspaceRoot Path to the root of the Angular workspace. + * @param main The `main` option pointing at the application entry point. While required per the schema file, it may be omitted by + * programmatic usages of `browser-esbuild`. + * @param entryPoints Set of entry points to use if provided. + * @returns An object mapping entry point names to their file paths. + */ +function normalizeEntryPoints(workspaceRoot, main, entryPoints = new Set()) { + if (main === '') { + throw new Error('`main` option cannot be an empty string.'); + } + // `main` and `entryPoints` are mutually exclusive. + if (main && entryPoints.size > 0) { + throw new Error('Only one of `main` or `entryPoints` may be provided.'); + } + if (!main && entryPoints.size === 0) { + // Schema should normally reject this case, but programmatic usages of the builder might make this mistake. + throw new Error('Either `main` or at least one `entryPoints` value must be provided.'); + } + // Schema types force `main` to always be provided, but it may be omitted when the builder is invoked programmatically. + if (main) { + // Use `main` alone. + return { 'main': node_path_1.default.join(workspaceRoot, main) }; + } + else { + // Use `entryPoints` alone. + const entryPointPaths = {}; + for (const entryPoint of entryPoints) { + const parsedEntryPoint = node_path_1.default.parse(entryPoint); + // Use the input file path without an extension as the "name" of the entry point dictating its output location. + // Relative entry points are generated at the same relative path in the output directory. + // Absolute entry points are always generated with the same file name in the root of the output directory. This includes absolute + // paths pointing at files actually within the workspace root. + const entryPointName = node_path_1.default.isAbsolute(entryPoint) + ? parsedEntryPoint.name + : node_path_1.default.join(parsedEntryPoint.dir, parsedEntryPoint.name); + // Get the full file path to the entry point input. + const entryPointPath = node_path_1.default.isAbsolute(entryPoint) + ? entryPoint + : node_path_1.default.join(workspaceRoot, entryPoint); + // Check for conflicts with previous entry points. + const existingEntryPointPath = entryPointPaths[entryPointName]; + if (existingEntryPointPath) { + throw new Error(`\`${existingEntryPointPath}\` and \`${entryPointPath}\` both output to the same location \`${entryPointName}\`.` + + ' Rename or move one of the files to fix the conflict.'); + } + entryPointPaths[entryPointName] = entryPointPath; + } + return entryPointPaths; + } +} +/** + * Normalize a directory path string. + * Currently only removes a trailing slash if present. + * @param path A path string. + * @returns A normalized path string. + */ +function normalizeDirectoryPath(path) { + const last = path[path.length - 1]; + if (last === '/' || last === '\\') { + return path.slice(0, -1); + } + return path; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"options.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/options.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 { BuilderContext } from '@angular-devkit/architect';\nimport fs from 'node:fs';\nimport { createRequire } from 'node:module';\nimport path from 'node:path';\nimport { normalizeAssetPatterns, normalizeOptimization, normalizeSourceMaps } from '../../utils';\nimport { normalizeCacheOptions } from '../../utils/normalize-cache';\nimport { generateEntryPoints } from '../../utils/package-chunk-sort';\nimport { findTailwindConfigurationFile } from '../../utils/tailwind';\nimport { getIndexInputFile, getIndexOutputFile } from '../../utils/webpack-browser-config';\nimport { globalScriptsByBundleName, normalizeGlobalStyles } from '../../webpack/utils/helpers';\nimport { Schema as BrowserBuilderOptions, OutputHashing } from './schema';\n\nexport type NormalizedBrowserOptions = Awaited<ReturnType<typeof normalizeOptions>>;\n\n/** Internal options hidden from builder schema but available when invoked programmatically. */\ninterface InternalOptions {\n  /**\n   * Entry points to use for the compilation. Incompatible with `main`, which must not be provided. May be relative or absolute paths.\n   * If given a relative path, it is resolved relative to the current workspace and will generate an output at the same relative location\n   * in the output directory. If given an absolute path, the output will be generated in the root of the output directory with the same base\n   * name.\n   */\n  entryPoints?: Set<string>;\n\n  /** File extension to use for the generated output files. */\n  outExtension?: 'js' | 'mjs';\n}\n\n/** Full set of options for `browser-esbuild` builder. */\nexport type BrowserEsbuildOptions = Omit<BrowserBuilderOptions & InternalOptions, 'main'> & {\n  // `main` can be `undefined` if `entryPoints` is used.\n  main?: string;\n};\n\n/**\n * Normalize the user provided options by creating full paths for all path based options\n * and converting multi-form options into a single form that can be directly used\n * by the build process.\n *\n * @param context The context for current builder execution.\n * @param projectName The name of the project for the current execution.\n * @param options An object containing the options to use for the build.\n * @returns An object containing normalized options required to perform the build.\n */\nexport async function normalizeOptions(\n  context: BuilderContext,\n  projectName: string,\n  options: BrowserEsbuildOptions,\n) {\n  const workspaceRoot = context.workspaceRoot;\n  const projectMetadata = await context.getProjectMetadata(projectName);\n  const projectRoot = normalizeDirectoryPath(\n    path.join(workspaceRoot, (projectMetadata.root as string | undefined) ?? ''),\n  );\n  const projectSourceRoot = normalizeDirectoryPath(\n    path.join(workspaceRoot, (projectMetadata.sourceRoot as string | undefined) ?? 'src'),\n  );\n\n  const cacheOptions = normalizeCacheOptions(projectMetadata, workspaceRoot);\n\n  const entryPoints = normalizeEntryPoints(workspaceRoot, options.main, options.entryPoints);\n  const tsconfig = path.join(workspaceRoot, options.tsConfig);\n  const outputPath = normalizeDirectoryPath(path.join(workspaceRoot, options.outputPath));\n  const optimizationOptions = normalizeOptimization(options.optimization);\n  const sourcemapOptions = normalizeSourceMaps(options.sourceMap ?? false);\n  const assets = options.assets?.length\n    ? normalizeAssetPatterns(options.assets, workspaceRoot, projectRoot, projectSourceRoot)\n    : undefined;\n\n  const outputNames = {\n    bundles:\n      options.outputHashing === OutputHashing.All || options.outputHashing === OutputHashing.Bundles\n        ? '[name].[hash]'\n        : '[name]',\n    media:\n      options.outputHashing === OutputHashing.All || options.outputHashing === OutputHashing.Media\n        ? '[name].[hash]'\n        : '[name]',\n  };\n  if (options.resourcesOutputPath) {\n    outputNames.media = path.join(options.resourcesOutputPath, outputNames.media);\n  }\n\n  let fileReplacements: Record<string, string> | undefined;\n  if (options.fileReplacements) {\n    for (const replacement of options.fileReplacements) {\n      fileReplacements ??= {};\n      fileReplacements[path.join(workspaceRoot, replacement.replace)] = path.join(\n        workspaceRoot,\n        replacement.with,\n      );\n    }\n  }\n\n  const globalStyles: { name: string; files: string[]; initial: boolean }[] = [];\n  if (options.styles?.length) {\n    const { entryPoints: stylesheetEntrypoints, noInjectNames } = normalizeGlobalStyles(\n      options.styles || [],\n    );\n    for (const [name, files] of Object.entries(stylesheetEntrypoints)) {\n      globalStyles.push({ name, files, initial: !noInjectNames.includes(name) });\n    }\n  }\n\n  const globalScripts: { name: string; files: string[]; initial: boolean }[] = [];\n  if (options.scripts?.length) {\n    for (const { bundleName, paths, inject } of globalScriptsByBundleName(options.scripts)) {\n      globalScripts.push({ name: bundleName, files: paths, initial: inject });\n    }\n  }\n\n  let tailwindConfiguration: { file: string; package: string } | undefined;\n  const tailwindConfigurationPath = await findTailwindConfigurationFile(workspaceRoot, projectRoot);\n  if (tailwindConfigurationPath) {\n    // Create a node resolver at the project root as a directory\n    const resolver = createRequire(projectRoot + '/');\n    try {\n      tailwindConfiguration = {\n        file: tailwindConfigurationPath,\n        package: resolver.resolve('tailwindcss'),\n      };\n    } catch {\n      const relativeTailwindConfigPath = path.relative(workspaceRoot, tailwindConfigurationPath);\n      context.logger.warn(\n        `Tailwind CSS configuration file found (${relativeTailwindConfigPath})` +\n          ` but the 'tailwindcss' package is not installed.` +\n          ` To enable Tailwind CSS, please install the 'tailwindcss' package.`,\n      );\n    }\n  }\n\n  let serviceWorkerOptions;\n  if (options.serviceWorker) {\n    // If ngswConfigPath is not specified, the default is 'ngsw-config.json' within the project root\n    serviceWorkerOptions = options.ngswConfigPath\n      ? path.join(workspaceRoot, options.ngswConfigPath)\n      : path.join(projectRoot, 'ngsw-config.json');\n  }\n\n  let indexHtmlOptions;\n  if (options.index) {\n    indexHtmlOptions = {\n      input: path.join(workspaceRoot, getIndexInputFile(options.index)),\n      // The output file will be created within the configured output path\n      output: getIndexOutputFile(options.index),\n      // TODO: Use existing information from above to create the insertion order\n      insertionOrder: generateEntryPoints({\n        scripts: options.scripts ?? [],\n        styles: options.styles ?? [],\n      }),\n    };\n  }\n\n  // Initial options to keep\n  const {\n    allowedCommonJsDependencies,\n    aot,\n    baseHref,\n    buildOptimizer,\n    crossOrigin,\n    externalDependencies,\n    extractLicenses,\n    inlineStyleLanguage = 'css',\n    outExtension,\n    poll,\n    polyfills,\n    preserveSymlinks,\n    statsJson,\n    stylePreprocessorOptions,\n    subresourceIntegrity,\n    verbose,\n    watch,\n    progress,\n  } = options;\n\n  // Return all the normalized options\n  return {\n    advancedOptimizations: buildOptimizer,\n    allowedCommonJsDependencies,\n    baseHref,\n    cacheOptions,\n    crossOrigin,\n    externalDependencies,\n    extractLicenses,\n    inlineStyleLanguage,\n    jit: !aot,\n    stats: !!statsJson,\n    polyfills: polyfills === undefined || Array.isArray(polyfills) ? polyfills : [polyfills],\n    poll,\n    progress: progress ?? true,\n    // If not explicitly set, default to the Node.js process argument\n    preserveSymlinks: preserveSymlinks ?? process.execArgv.includes('--preserve-symlinks'),\n    stylePreprocessorOptions,\n    subresourceIntegrity,\n    verbose,\n    watch,\n    workspaceRoot,\n    entryPoints,\n    optimizationOptions,\n    outputPath,\n    outExtension,\n    sourcemapOptions,\n    tsconfig,\n    projectRoot,\n    assets,\n    outputNames,\n    fileReplacements,\n    globalStyles,\n    globalScripts,\n    serviceWorkerOptions,\n    indexHtmlOptions,\n    tailwindConfiguration,\n  };\n}\n\n/**\n * Normalize entry point options. To maintain compatibility with the legacy browser builder, we need a single `main` option which defines a\n * single entry point. However, we also want to support multiple entry points as an internal option. The two options are mutually exclusive\n * and if `main` is provided it will be used as the sole entry point. If `entryPoints` are provided, they will be used as the set of entry\n * points.\n *\n * @param workspaceRoot Path to the root of the Angular workspace.\n * @param main The `main` option pointing at the application entry point. While required per the schema file, it may be omitted by\n *     programmatic usages of `browser-esbuild`.\n * @param entryPoints Set of entry points to use if provided.\n * @returns An object mapping entry point names to their file paths.\n */\nfunction normalizeEntryPoints(\n  workspaceRoot: string,\n  main: string | undefined,\n  entryPoints: Set<string> = new Set(),\n): Record<string, string> {\n  if (main === '') {\n    throw new Error('`main` option cannot be an empty string.');\n  }\n\n  // `main` and `entryPoints` are mutually exclusive.\n  if (main && entryPoints.size > 0) {\n    throw new Error('Only one of `main` or `entryPoints` may be provided.');\n  }\n  if (!main && entryPoints.size === 0) {\n    // Schema should normally reject this case, but programmatic usages of the builder might make this mistake.\n    throw new Error('Either `main` or at least one `entryPoints` value must be provided.');\n  }\n\n  // Schema types force `main` to always be provided, but it may be omitted when the builder is invoked programmatically.\n  if (main) {\n    // Use `main` alone.\n    return { 'main': path.join(workspaceRoot, main) };\n  } else {\n    // Use `entryPoints` alone.\n    const entryPointPaths: Record<string, string> = {};\n    for (const entryPoint of entryPoints) {\n      const parsedEntryPoint = path.parse(entryPoint);\n\n      // Use the input file path without an extension as the \"name\" of the entry point dictating its output location.\n      // Relative entry points are generated at the same relative path in the output directory.\n      // Absolute entry points are always generated with the same file name in the root of the output directory. This includes absolute\n      // paths pointing at files actually within the workspace root.\n      const entryPointName = path.isAbsolute(entryPoint)\n        ? parsedEntryPoint.name\n        : path.join(parsedEntryPoint.dir, parsedEntryPoint.name);\n\n      // Get the full file path to the entry point input.\n      const entryPointPath = path.isAbsolute(entryPoint)\n        ? entryPoint\n        : path.join(workspaceRoot, entryPoint);\n\n      // Check for conflicts with previous entry points.\n      const existingEntryPointPath = entryPointPaths[entryPointName];\n      if (existingEntryPointPath) {\n        throw new Error(\n          `\\`${existingEntryPointPath}\\` and \\`${entryPointPath}\\` both output to the same location \\`${entryPointName}\\`.` +\n            ' Rename or move one of the files to fix the conflict.',\n        );\n      }\n\n      entryPointPaths[entryPointName] = entryPointPath;\n    }\n\n    return entryPointPaths;\n  }\n}\n\n/**\n * Normalize a directory path string.\n * Currently only removes a trailing slash if present.\n * @param path A path string.\n * @returns A normalized path string.\n */\nfunction normalizeDirectoryPath(path: string): string {\n  const last = path[path.length - 1];\n  if (last === '/' || last === '\\\\') {\n    return path.slice(0, -1);\n  }\n\n  return path;\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/profiling.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/profiling.d.ts new file mode 100644 index 00000000..809125dd --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/profiling.d.ts @@ -0,0 +1,11 @@ +/** + * @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 + */ +export declare function resetCumulativeDurations(): void; +export declare function logCumulativeDurations(): void; +export declare function profileAsync(name: string, action: () => Promise, cumulative?: boolean): Promise; +export declare function profileSync(name: string, action: () => T, cumulative?: boolean): T; diff --git a/artifacts/build-angular/src/builders/browser-esbuild/profiling.js b/artifacts/build-angular/src/builders/browser-esbuild/profiling.js new file mode 100644 index 00000000..61be96d1 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/profiling.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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.profileSync = exports.profileAsync = exports.logCumulativeDurations = exports.resetCumulativeDurations = void 0; +const environment_options_1 = require("../../utils/environment-options"); +let cumulativeDurations; +function resetCumulativeDurations() { + cumulativeDurations?.clear(); +} +exports.resetCumulativeDurations = resetCumulativeDurations; +function logCumulativeDurations() { + if (!environment_options_1.debugPerformance || !cumulativeDurations) { + return; + } + for (const [name, durations] of cumulativeDurations) { + let total = 0; + let min; + let max; + for (const duration of durations) { + total += duration; + if (min === undefined || duration < min) { + min = duration; + } + if (max === undefined || duration > max) { + max = duration; + } + } + const average = total / durations.length; + // eslint-disable-next-line no-console + console.log(`DURATION[${name}]: ${total.toFixed(9)}s [count: ${durations.length}; avg: ${average.toFixed(9)}s; min: ${min?.toFixed(9)}s; max: ${max?.toFixed(9)}s]`); + } +} +exports.logCumulativeDurations = logCumulativeDurations; +function recordDuration(name, startTime, cumulative) { + const duration = Number(process.hrtime.bigint() - startTime) / 10 ** 9; + if (cumulative) { + cumulativeDurations ?? (cumulativeDurations = new Map()); + const durations = cumulativeDurations.get(name) ?? []; + durations.push(duration); + cumulativeDurations.set(name, durations); + } + else { + // eslint-disable-next-line no-console + console.log(`DURATION[${name}]: ${duration.toFixed(9)}s`); + } +} +async function profileAsync(name, action, cumulative) { + if (!environment_options_1.debugPerformance) { + return action(); + } + const startTime = process.hrtime.bigint(); + try { + return await action(); + } + finally { + recordDuration(name, startTime, cumulative); + } +} +exports.profileAsync = profileAsync; +function profileSync(name, action, cumulative) { + if (!environment_options_1.debugPerformance) { + return action(); + } + const startTime = process.hrtime.bigint(); + try { + return action(); + } + finally { + recordDuration(name, startTime, cumulative); + } +} +exports.profileSync = profileSync; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/schema.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/schema.d.ts new file mode 100644 index 00000000..be583b92 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/schema.d.ts @@ -0,0 +1,415 @@ +/** + * Browser target options + */ +export interface Schema { + /** + * A list of CommonJS packages that are allowed to be used without a build time warning. + */ + allowedCommonJsDependencies?: string[]; + /** + * Build using Ahead of Time compilation. + */ + aot?: boolean; + /** + * List of static application assets. + */ + assets?: AssetPattern[]; + /** + * Base url for the application being built. + */ + baseHref?: string; + /** + * Budget thresholds to ensure parts of your application stay within boundaries which you + * set. + */ + budgets?: Budget[]; + /** + * Enables advanced build optimizations when using the 'aot' option. + */ + buildOptimizer?: boolean; + /** + * Generate a seperate bundle containing code used across multiple bundles. + */ + commonChunk?: boolean; + /** + * Define the crossorigin attribute setting of elements that provide CORS support. + */ + crossOrigin?: CrossOrigin; + /** + * Delete the output path before building. + */ + deleteOutputPath?: boolean; + /** + * URL where files will be deployed. + * @deprecated Use "baseHref" option, "APP_BASE_HREF" DI token or a combination of both + * instead. For more information, see https://angular.io/guide/deployment#the-deploy-url. + */ + deployUrl?: string; + /** + * Exclude the listed external dependencies from being bundled into the bundle. Instead, the + * created bundle relies on these dependencies to be available during runtime. + */ + externalDependencies?: string[]; + /** + * Extract all licenses in a separate file. + */ + extractLicenses?: boolean; + /** + * Replace compilation source files with other compilation source files in the build. + */ + fileReplacements?: FileReplacement[]; + /** + * How to handle duplicate translations for i18n. + */ + i18nDuplicateTranslation?: I18NTranslation; + /** + * How to handle missing translations for i18n. + */ + i18nMissingTranslation?: I18NTranslation; + /** + * Configures the generation of the application's HTML index. + */ + index: any; + /** + * The stylesheet language to use for the application's inline component styles. + */ + inlineStyleLanguage?: InlineStyleLanguage; + /** + * Translate the bundles in one or more locales. + */ + localize?: Localize; + /** + * The full path for the main entry point to the app, relative to the current workspace. + */ + main: string; + /** + * Use file name for lazy loaded chunks. + */ + namedChunks?: boolean; + /** + * Path to ngsw-config.json. + */ + ngswConfigPath?: string; + /** + * Enables optimization of the build output. Including minification of scripts and styles, + * tree-shaking, dead-code elimination, inlining of critical CSS and fonts inlining. For + * more information, see + * https://angular.io/guide/workspace-config#optimization-configuration. + */ + optimization?: OptimizationUnion; + /** + * Define the output filename cache-busting hashing mode. + */ + outputHashing?: OutputHashing; + /** + * The full path for the new output directory, relative to the current workspace. + * By default, writes output to a folder named dist/ in the current project. + */ + outputPath: string; + /** + * Enable and define the file watching poll time period in milliseconds. + */ + poll?: number; + /** + * Polyfills to be included in the build. + */ + polyfills?: Polyfills; + /** + * Do not use the real path when resolving modules. If unset then will default to `true` if + * NodeJS option --preserve-symlinks is set. + */ + preserveSymlinks?: boolean; + /** + * Log progress to the console while building. + */ + progress?: boolean; + /** + * The path where style resources will be placed, relative to outputPath. + */ + resourcesOutputPath?: string; + /** + * Global scripts to be included in the build. + */ + scripts?: ScriptElement[]; + /** + * Generates a service worker config for production builds. + */ + serviceWorker?: boolean; + /** + * Output source maps for scripts and styles. For more information, see + * https://angular.io/guide/workspace-config#source-map-configuration. + */ + sourceMap?: SourceMapUnion; + /** + * Generates a 'stats.json' file which can be analyzed using tools such as + * 'webpack-bundle-analyzer'. + */ + statsJson?: boolean; + /** + * Options to pass to style preprocessors. + */ + stylePreprocessorOptions?: StylePreprocessorOptions; + /** + * Global styles to be included in the build. + */ + styles?: StyleElement[]; + /** + * Enables the use of subresource integrity validation. + */ + subresourceIntegrity?: boolean; + /** + * The full path for the TypeScript configuration file, relative to the current workspace. + */ + tsConfig: string; + /** + * Generate a seperate bundle containing only vendor libraries. This option should only be + * used for development to reduce the incremental compilation time. + */ + vendorChunk?: boolean; + /** + * Adds more details to output logging. + */ + verbose?: boolean; + /** + * Run build when files change. + */ + watch?: boolean; + /** + * TypeScript configuration for Web Worker modules. + */ + webWorkerTsConfig?: string; +} +export 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 Budget { + /** + * The baseline size for comparison. + */ + baseline?: string; + /** + * The threshold for error relative to the baseline (min & max). + */ + error?: string; + /** + * The maximum threshold for error relative to the baseline. + */ + maximumError?: string; + /** + * The maximum threshold for warning relative to the baseline. + */ + maximumWarning?: string; + /** + * The minimum threshold for error relative to the baseline. + */ + minimumError?: string; + /** + * The minimum threshold for warning relative to the baseline. + */ + minimumWarning?: string; + /** + * The name of the bundle. + */ + name?: string; + /** + * The type of budget. + */ + type: Type; + /** + * The threshold for warning relative to the baseline (min & max). + */ + warning?: string; +} +/** + * The type of budget. + */ +export declare enum Type { + All = "all", + AllScript = "allScript", + Any = "any", + AnyComponentStyle = "anyComponentStyle", + AnyScript = "anyScript", + Bundle = "bundle", + Initial = "initial" +} +/** + * Define the crossorigin attribute setting of elements that provide CORS support. + */ +export declare enum CrossOrigin { + Anonymous = "anonymous", + None = "none", + UseCredentials = "use-credentials" +} +export interface FileReplacement { + replace: string; + with: string; +} +/** + * How to handle duplicate translations for i18n. + * + * How to handle missing translations for i18n. + */ +export declare enum I18NTranslation { + Error = "error", + Ignore = "ignore", + Warning = "warning" +} +/** + * The stylesheet language to use for the application's inline component styles. + */ +export declare enum InlineStyleLanguage { + Css = "css", + Less = "less", + Sass = "sass", + Scss = "scss" +} +/** + * Translate the bundles in one or more locales. + */ +export type Localize = string[] | boolean; +/** + * Enables optimization of the build output. Including minification of scripts and styles, + * tree-shaking, dead-code elimination, inlining of critical CSS and fonts inlining. For + * more information, see + * https://angular.io/guide/workspace-config#optimization-configuration. + */ +export type OptimizationUnion = boolean | OptimizationClass; +export interface OptimizationClass { + /** + * Enables optimization for fonts. This option requires internet access. `HTTPS_PROXY` + * environment variable can be used to specify a proxy server. + */ + fonts?: FontsUnion; + /** + * Enables optimization of the scripts output. + */ + scripts?: boolean; + /** + * Enables optimization of the styles output. + */ + styles?: StylesUnion; +} +/** + * Enables optimization for fonts. This option requires internet access. `HTTPS_PROXY` + * environment variable can be used to specify a proxy server. + */ +export type FontsUnion = boolean | FontsClass; +export interface FontsClass { + /** + * Reduce render blocking requests by inlining external Google Fonts and Adobe Fonts CSS + * definitions in the application's HTML index file. This option requires internet access. + * `HTTPS_PROXY` environment variable can be used to specify a proxy server. + */ + inline?: boolean; +} +/** + * Enables optimization of the styles output. + */ +export type StylesUnion = boolean | StylesClass; +export interface StylesClass { + /** + * Extract and inline critical CSS definitions to improve first paint time. + */ + inlineCritical?: boolean; + /** + * Minify CSS definitions by removing extraneous whitespace and comments, merging + * identifiers and minimizing values. + */ + minify?: boolean; +} +/** + * Define the output filename cache-busting hashing mode. + */ +export declare enum OutputHashing { + All = "all", + Bundles = "bundles", + Media = "media", + None = "none" +} +/** + * Polyfills to be included in the build. + */ +export type Polyfills = string[] | string; +export type ScriptElement = ScriptClass | string; +export interface ScriptClass { + /** + * The bundle name for this extra entry point. + */ + bundleName?: string; + /** + * If the bundle will be referenced in the HTML file. + */ + inject?: boolean; + /** + * The file to include. + */ + input: string; +} +/** + * Output source maps for scripts and styles. For more information, see + * https://angular.io/guide/workspace-config#source-map-configuration. + */ +export type SourceMapUnion = boolean | SourceMapClass; +export interface SourceMapClass { + /** + * Output source maps used for error reporting tools. + */ + hidden?: boolean; + /** + * Output source maps for all scripts. + */ + scripts?: boolean; + /** + * Output source maps for all styles. + */ + styles?: boolean; + /** + * Resolve vendor packages source maps. + */ + vendor?: boolean; +} +/** + * Options to pass to style preprocessors. + */ +export interface StylePreprocessorOptions { + /** + * Paths to include. Paths will be resolved to workspace root. + */ + includePaths?: string[]; +} +export type StyleElement = StyleClass | string; +export interface StyleClass { + /** + * The bundle name for this extra entry point. + */ + bundleName?: string; + /** + * If the bundle will be referenced in the HTML file. + */ + inject?: boolean; + /** + * The file to include. + */ + input: string; +} diff --git a/artifacts/build-angular/src/builders/browser-esbuild/schema.js b/artifacts/build-angular/src/builders/browser-esbuild/schema.js new file mode 100644 index 00000000..c97551be --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/schema.js @@ -0,0 +1,59 @@ +"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 }); +exports.OutputHashing = exports.InlineStyleLanguage = exports.I18NTranslation = exports.CrossOrigin = exports.Type = void 0; +/** + * The type of budget. + */ +var Type; +(function (Type) { + Type["All"] = "all"; + Type["AllScript"] = "allScript"; + Type["Any"] = "any"; + Type["AnyComponentStyle"] = "anyComponentStyle"; + Type["AnyScript"] = "anyScript"; + Type["Bundle"] = "bundle"; + Type["Initial"] = "initial"; +})(Type = exports.Type || (exports.Type = {})); +/** + * Define the crossorigin attribute setting of elements that provide CORS support. + */ +var CrossOrigin; +(function (CrossOrigin) { + CrossOrigin["Anonymous"] = "anonymous"; + CrossOrigin["None"] = "none"; + CrossOrigin["UseCredentials"] = "use-credentials"; +})(CrossOrigin = exports.CrossOrigin || (exports.CrossOrigin = {})); +/** + * How to handle duplicate translations for i18n. + * + * How to handle missing translations for i18n. + */ +var I18NTranslation; +(function (I18NTranslation) { + I18NTranslation["Error"] = "error"; + I18NTranslation["Ignore"] = "ignore"; + I18NTranslation["Warning"] = "warning"; +})(I18NTranslation = exports.I18NTranslation || (exports.I18NTranslation = {})); +/** + * The stylesheet language to use for the application's inline component styles. + */ +var InlineStyleLanguage; +(function (InlineStyleLanguage) { + InlineStyleLanguage["Css"] = "css"; + InlineStyleLanguage["Less"] = "less"; + InlineStyleLanguage["Sass"] = "sass"; + InlineStyleLanguage["Scss"] = "scss"; +})(InlineStyleLanguage = exports.InlineStyleLanguage || (exports.InlineStyleLanguage = {})); +/** + * Define the output filename cache-busting hashing mode. + */ +var OutputHashing; +(function (OutputHashing) { + OutputHashing["All"] = "all"; + OutputHashing["Bundles"] = "bundles"; + OutputHashing["Media"] = "media"; + OutputHashing["None"] = "none"; +})(OutputHashing = exports.OutputHashing || (exports.OutputHashing = {})); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/schema.ts"],"names":[],"mappings":";AACA,mFAAmF;AACnF,oFAAoF;;;AAyPpF;;GAEG;AACH,IAAY,IAQX;AARD,WAAY,IAAI;IACZ,mBAAW,CAAA;IACX,+BAAuB,CAAA;IACvB,mBAAW,CAAA;IACX,+CAAuC,CAAA;IACvC,+BAAuB,CAAA;IACvB,yBAAiB,CAAA;IACjB,2BAAmB,CAAA;AACvB,CAAC,EARW,IAAI,GAAJ,YAAI,KAAJ,YAAI,QAQf;AAED;;GAEG;AACH,IAAY,WAIX;AAJD,WAAY,WAAW;IACnB,sCAAuB,CAAA;IACvB,4BAAa,CAAA;IACb,iDAAkC,CAAA;AACtC,CAAC,EAJW,WAAW,GAAX,mBAAW,KAAX,mBAAW,QAItB;AAOD;;;;GAIG;AACH,IAAY,eAIX;AAJD,WAAY,eAAe;IACvB,kCAAe,CAAA;IACf,oCAAiB,CAAA;IACjB,sCAAmB,CAAA;AACvB,CAAC,EAJW,eAAe,GAAf,uBAAe,KAAf,uBAAe,QAI1B;AAED;;GAEG;AACH,IAAY,mBAKX;AALD,WAAY,mBAAmB;IAC3B,kCAAW,CAAA;IACX,oCAAa,CAAA;IACb,oCAAa,CAAA;IACb,oCAAa,CAAA;AACjB,CAAC,EALW,mBAAmB,GAAnB,2BAAmB,KAAnB,2BAAmB,QAK9B;AA+DD;;GAEG;AACH,IAAY,aAKX;AALD,WAAY,aAAa;IACrB,4BAAW,CAAA;IACX,oCAAmB,CAAA;IACnB,gCAAe,CAAA;IACf,8BAAa,CAAA;AACjB,CAAC,EALW,aAAa,GAAb,qBAAa,KAAb,qBAAa,QAKxB","sourcesContent":["\n// THIS FILE IS AUTOMATICALLY GENERATED. TO UPDATE THIS FILE YOU NEED TO CHANGE THE\n// CORRESPONDING JSON SCHEMA FILE, THEN RUN devkit-admin build (or bazel build ...).\n\n/**\n * Browser target options\n */\nexport interface Schema {\n    /**\n     * A list of CommonJS packages that are allowed to be used without a build time warning.\n     */\n    allowedCommonJsDependencies?: string[];\n    /**\n     * Build using Ahead of Time compilation.\n     */\n    aot?: boolean;\n    /**\n     * List of static application assets.\n     */\n    assets?: AssetPattern[];\n    /**\n     * Base url for the application being built.\n     */\n    baseHref?: string;\n    /**\n     * Budget thresholds to ensure parts of your application stay within boundaries which you\n     * set.\n     */\n    budgets?: Budget[];\n    /**\n     * Enables advanced build optimizations when using the 'aot' option.\n     */\n    buildOptimizer?: boolean;\n    /**\n     * Generate a seperate bundle containing code used across multiple bundles.\n     */\n    commonChunk?: boolean;\n    /**\n     * Define the crossorigin attribute setting of elements that provide CORS support.\n     */\n    crossOrigin?: CrossOrigin;\n    /**\n     * Delete the output path before building.\n     */\n    deleteOutputPath?: boolean;\n    /**\n     * URL where files will be deployed.\n     * @deprecated Use \"baseHref\" option, \"APP_BASE_HREF\" DI token or a combination of both\n     * instead. For more information, see https://angular.io/guide/deployment#the-deploy-url.\n     */\n    deployUrl?: string;\n    /**\n     * Exclude the listed external dependencies from being bundled into the bundle. Instead, the\n     * created bundle relies on these dependencies to be available during runtime.\n     */\n    externalDependencies?: string[];\n    /**\n     * Extract all licenses in a separate file.\n     */\n    extractLicenses?: boolean;\n    /**\n     * Replace compilation source files with other compilation source files in the build.\n     */\n    fileReplacements?: FileReplacement[];\n    /**\n     * How to handle duplicate translations for i18n.\n     */\n    i18nDuplicateTranslation?: I18NTranslation;\n    /**\n     * How to handle missing translations for i18n.\n     */\n    i18nMissingTranslation?: I18NTranslation;\n    /**\n     * Configures the generation of the application's HTML index.\n     */\n    index: any;\n    /**\n     * The stylesheet language to use for the application's inline component styles.\n     */\n    inlineStyleLanguage?: InlineStyleLanguage;\n    /**\n     * Translate the bundles in one or more locales.\n     */\n    localize?: Localize;\n    /**\n     * The full path for the main entry point to the app, relative to the current workspace.\n     */\n    main: string;\n    /**\n     * Use file name for lazy loaded chunks.\n     */\n    namedChunks?: boolean;\n    /**\n     * Path to ngsw-config.json.\n     */\n    ngswConfigPath?: string;\n    /**\n     * Enables optimization of the build output. Including minification of scripts and styles,\n     * tree-shaking, dead-code elimination, inlining of critical CSS and fonts inlining. For\n     * more information, see\n     * https://angular.io/guide/workspace-config#optimization-configuration.\n     */\n    optimization?: OptimizationUnion;\n    /**\n     * Define the output filename cache-busting hashing mode.\n     */\n    outputHashing?: OutputHashing;\n    /**\n     * The full path for the new output directory, relative to the current workspace.\n     * By default, writes output to a folder named dist/ in the current project.\n     */\n    outputPath: string;\n    /**\n     * Enable and define the file watching poll time period in milliseconds.\n     */\n    poll?: number;\n    /**\n     * Polyfills to be included in the build.\n     */\n    polyfills?: Polyfills;\n    /**\n     * Do not use the real path when resolving modules. If unset then will default to `true` if\n     * NodeJS option --preserve-symlinks is set.\n     */\n    preserveSymlinks?: boolean;\n    /**\n     * Log progress to the console while building.\n     */\n    progress?: boolean;\n    /**\n     * The path where style resources will be placed, relative to outputPath.\n     */\n    resourcesOutputPath?: string;\n    /**\n     * Global scripts to be included in the build.\n     */\n    scripts?: ScriptElement[];\n    /**\n     * Generates a service worker config for production builds.\n     */\n    serviceWorker?: boolean;\n    /**\n     * Output source maps for scripts and styles. For more information, see\n     * https://angular.io/guide/workspace-config#source-map-configuration.\n     */\n    sourceMap?: SourceMapUnion;\n    /**\n     * Generates a 'stats.json' file which can be analyzed using tools such as\n     * 'webpack-bundle-analyzer'.\n     */\n    statsJson?: boolean;\n    /**\n     * Options to pass to style preprocessors.\n     */\n    stylePreprocessorOptions?: StylePreprocessorOptions;\n    /**\n     * Global styles to be included in the build.\n     */\n    styles?: StyleElement[];\n    /**\n     * Enables the use of subresource integrity validation.\n     */\n    subresourceIntegrity?: boolean;\n    /**\n     * The full path for the TypeScript configuration file, relative to the current workspace.\n     */\n    tsConfig: string;\n    /**\n     * Generate a seperate bundle containing only vendor libraries. This option should only be\n     * used for development to reduce the incremental compilation time.\n     */\n    vendorChunk?: boolean;\n    /**\n     * Adds more details to output logging.\n     */\n    verbose?: boolean;\n    /**\n     * Run build when files change.\n     */\n    watch?: boolean;\n    /**\n     * TypeScript configuration for Web Worker modules.\n     */\n    webWorkerTsConfig?: string;\n}\n\nexport type AssetPattern = AssetPatternClass | string;\n\nexport interface AssetPatternClass {\n    /**\n     * Allow glob patterns to follow symlink directories. This allows subdirectories of the\n     * symlink to be searched.\n     */\n    followSymlinks?: boolean;\n    /**\n     * The pattern to match.\n     */\n    glob: string;\n    /**\n     * An array of globs to ignore.\n     */\n    ignore?: string[];\n    /**\n     * The input directory path in which to apply 'glob'. Defaults to the project root.\n     */\n    input: string;\n    /**\n     * Absolute path within the output.\n     */\n    output: string;\n}\n\nexport interface Budget {\n    /**\n     * The baseline size for comparison.\n     */\n    baseline?: string;\n    /**\n     * The threshold for error relative to the baseline (min & max).\n     */\n    error?: string;\n    /**\n     * The maximum threshold for error relative to the baseline.\n     */\n    maximumError?: string;\n    /**\n     * The maximum threshold for warning relative to the baseline.\n     */\n    maximumWarning?: string;\n    /**\n     * The minimum threshold for error relative to the baseline.\n     */\n    minimumError?: string;\n    /**\n     * The minimum threshold for warning relative to the baseline.\n     */\n    minimumWarning?: string;\n    /**\n     * The name of the bundle.\n     */\n    name?: string;\n    /**\n     * The type of budget.\n     */\n    type: Type;\n    /**\n     * The threshold for warning relative to the baseline (min & max).\n     */\n    warning?: string;\n}\n\n/**\n * The type of budget.\n */\nexport enum Type {\n    All = \"all\",\n    AllScript = \"allScript\",\n    Any = \"any\",\n    AnyComponentStyle = \"anyComponentStyle\",\n    AnyScript = \"anyScript\",\n    Bundle = \"bundle\",\n    Initial = \"initial\",\n}\n\n/**\n * Define the crossorigin attribute setting of elements that provide CORS support.\n */\nexport enum CrossOrigin {\n    Anonymous = \"anonymous\",\n    None = \"none\",\n    UseCredentials = \"use-credentials\",\n}\n\nexport interface FileReplacement {\n    replace: string;\n    with:    string;\n}\n\n/**\n * How to handle duplicate translations for i18n.\n *\n * How to handle missing translations for i18n.\n */\nexport enum I18NTranslation {\n    Error = \"error\",\n    Ignore = \"ignore\",\n    Warning = \"warning\",\n}\n\n/**\n * The stylesheet language to use for the application's inline component styles.\n */\nexport enum InlineStyleLanguage {\n    Css = \"css\",\n    Less = \"less\",\n    Sass = \"sass\",\n    Scss = \"scss\",\n}\n\n/**\n * Translate the bundles in one or more locales.\n */\nexport type Localize = string[] | boolean;\n\n/**\n * Enables optimization of the build output. Including minification of scripts and styles,\n * tree-shaking, dead-code elimination, inlining of critical CSS and fonts inlining. For\n * more information, see\n * https://angular.io/guide/workspace-config#optimization-configuration.\n */\nexport type OptimizationUnion = boolean | OptimizationClass;\n\nexport interface OptimizationClass {\n    /**\n     * Enables optimization for fonts. This option requires internet access. `HTTPS_PROXY`\n     * environment variable can be used to specify a proxy server.\n     */\n    fonts?: FontsUnion;\n    /**\n     * Enables optimization of the scripts output.\n     */\n    scripts?: boolean;\n    /**\n     * Enables optimization of the styles output.\n     */\n    styles?: StylesUnion;\n}\n\n/**\n * Enables optimization for fonts. This option requires internet access. `HTTPS_PROXY`\n * environment variable can be used to specify a proxy server.\n */\nexport type FontsUnion = boolean | FontsClass;\n\nexport interface FontsClass {\n    /**\n     * Reduce render blocking requests by inlining external Google Fonts and Adobe Fonts CSS\n     * definitions in the application's HTML index file. This option requires internet access.\n     * `HTTPS_PROXY` environment variable can be used to specify a proxy server.\n     */\n    inline?: boolean;\n}\n\n/**\n * Enables optimization of the styles output.\n */\nexport type StylesUnion = boolean | StylesClass;\n\nexport interface StylesClass {\n    /**\n     * Extract and inline critical CSS definitions to improve first paint time.\n     */\n    inlineCritical?: boolean;\n    /**\n     * Minify CSS definitions by removing extraneous whitespace and comments, merging\n     * identifiers and minimizing values.\n     */\n    minify?: boolean;\n}\n\n/**\n * Define the output filename cache-busting hashing mode.\n */\nexport enum OutputHashing {\n    All = \"all\",\n    Bundles = \"bundles\",\n    Media = \"media\",\n    None = \"none\",\n}\n\n/**\n * Polyfills to be included in the build.\n */\nexport type Polyfills = string[] | string;\n\nexport type ScriptElement = ScriptClass | string;\n\nexport interface ScriptClass {\n    /**\n     * The bundle name for this extra entry point.\n     */\n    bundleName?: string;\n    /**\n     * If the bundle will be referenced in the HTML file.\n     */\n    inject?: boolean;\n    /**\n     * The file to include.\n     */\n    input: string;\n}\n\n/**\n * Output source maps for scripts and styles. For more information, see\n * https://angular.io/guide/workspace-config#source-map-configuration.\n */\nexport type SourceMapUnion = boolean | SourceMapClass;\n\nexport interface SourceMapClass {\n    /**\n     * Output source maps used for error reporting tools.\n     */\n    hidden?: boolean;\n    /**\n     * Output source maps for all scripts.\n     */\n    scripts?: boolean;\n    /**\n     * Output source maps for all styles.\n     */\n    styles?: boolean;\n    /**\n     * Resolve vendor packages source maps.\n     */\n    vendor?: boolean;\n}\n\n/**\n * Options to pass to style preprocessors.\n */\nexport interface StylePreprocessorOptions {\n    /**\n     * Paths to include. Paths will be resolved to workspace root.\n     */\n    includePaths?: string[];\n}\n\nexport type StyleElement = StyleClass | string;\n\nexport interface StyleClass {\n    /**\n     * The bundle name for this extra entry point.\n     */\n    bundleName?: string;\n    /**\n     * If the bundle will be referenced in the HTML file.\n     */\n    inject?: boolean;\n    /**\n     * The file to include.\n     */\n    input: string;\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/schema.json b/artifacts/build-angular/src/builders/browser-esbuild/schema.json new file mode 100644 index 00000000..0786d97d --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/schema.json @@ -0,0 +1,540 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema", + "title": "Esbuild browser schema for Build Facade.", + "description": "Browser target options", + "type": "object", + "properties": { + "assets": { + "type": "array", + "description": "List of static application assets.", + "default": [], + "items": { + "$ref": "#/definitions/assetPattern" + } + }, + "main": { + "type": "string", + "description": "The full path for the main entry point to the app, relative to the current workspace." + }, + "polyfills": { + "description": "Polyfills to be included in the build.", + "oneOf": [ + { + "type": "array", + "description": "A list of polyfills to include in the build. Can be a full path for a file, relative to the current workspace or module specifier. Example: 'zone.js'.", + "items": { + "type": "string", + "uniqueItems": true + }, + "default": [] + }, + { + "type": "string", + "description": "The full path for the polyfills file, relative to the current workspace or a module specifier. Example: 'zone.js'." + } + ] + }, + "tsConfig": { + "type": "string", + "description": "The full path for the TypeScript configuration file, relative to the current workspace." + }, + "scripts": { + "description": "Global scripts to be included in the build.", + "type": "array", + "default": [], + "items": { + "oneOf": [ + { + "type": "object", + "properties": { + "input": { + "type": "string", + "description": "The file to include.", + "pattern": "\\.[cm]?jsx?$" + }, + "bundleName": { + "type": "string", + "pattern": "^[\\w\\-.]*$", + "description": "The bundle name for this extra entry point." + }, + "inject": { + "type": "boolean", + "description": "If the bundle will be referenced in the HTML file.", + "default": true + } + }, + "additionalProperties": false, + "required": ["input"] + }, + { + "type": "string", + "description": "The JavaScript/TypeScript file or package containing the file to include." + } + ] + } + }, + "styles": { + "description": "Global styles to be included in the build.", + "type": "array", + "default": [], + "items": { + "oneOf": [ + { + "type": "object", + "properties": { + "input": { + "type": "string", + "description": "The file to include.", + "pattern": "\\.(?:css|scss|sass|less)$" + }, + "bundleName": { + "type": "string", + "pattern": "^[\\w\\-.]*$", + "description": "The bundle name for this extra entry point." + }, + "inject": { + "type": "boolean", + "description": "If the bundle will be referenced in the HTML file.", + "default": true + } + }, + "additionalProperties": false, + "required": ["input"] + }, + { + "type": "string", + "description": "The file to include.", + "pattern": "\\.(?:css|scss|sass|less)$" + } + ] + } + }, + "inlineStyleLanguage": { + "description": "The stylesheet language to use for the application's inline component styles.", + "type": "string", + "default": "css", + "enum": ["css", "less", "sass", "scss"] + }, + "stylePreprocessorOptions": { + "description": "Options to pass to style preprocessors.", + "type": "object", + "properties": { + "includePaths": { + "description": "Paths to include. Paths will be resolved to workspace root.", + "type": "array", + "items": { + "type": "string" + }, + "default": [] + } + }, + "additionalProperties": false + }, + "externalDependencies": { + "description": "Exclude the listed external dependencies from being bundled into the bundle. Instead, the created bundle relies on these dependencies to be available during runtime.", + "type": "array", + "items": { + "type": "string" + }, + "default": [] + }, + "optimization": { + "description": "Enables optimization of the build output. Including minification of scripts and styles, tree-shaking, dead-code elimination, inlining of critical CSS and fonts inlining. For more information, see https://angular.io/guide/workspace-config#optimization-configuration.", + "default": true, + "x-user-analytics": "ep.ng_optimization", + "oneOf": [ + { + "type": "object", + "properties": { + "scripts": { + "type": "boolean", + "description": "Enables optimization of the scripts output.", + "default": true + }, + "styles": { + "description": "Enables optimization of the styles output.", + "default": true, + "oneOf": [ + { + "type": "object", + "properties": { + "minify": { + "type": "boolean", + "description": "Minify CSS definitions by removing extraneous whitespace and comments, merging identifiers and minimizing values.", + "default": true + }, + "inlineCritical": { + "type": "boolean", + "description": "Extract and inline critical CSS definitions to improve first paint time.", + "default": true + } + }, + "additionalProperties": false + }, + { + "type": "boolean" + } + ] + }, + "fonts": { + "description": "Enables optimization for fonts. This option requires internet access. `HTTPS_PROXY` environment variable can be used to specify a proxy server.", + "default": true, + "oneOf": [ + { + "type": "object", + "properties": { + "inline": { + "type": "boolean", + "description": "Reduce render blocking requests by inlining external Google Fonts and Adobe Fonts CSS definitions in the application's HTML index file. This option requires internet access. `HTTPS_PROXY` environment variable can be used to specify a proxy server.", + "default": true + } + }, + "additionalProperties": false + }, + { + "type": "boolean" + } + ] + } + }, + "additionalProperties": false + }, + { + "type": "boolean" + } + ] + }, + "fileReplacements": { + "description": "Replace compilation source files with other compilation source files in the build.", + "type": "array", + "items": { + "$ref": "#/definitions/fileReplacement" + }, + "default": [] + }, + "outputPath": { + "type": "string", + "description": "The full path for the new output directory, relative to the current workspace.\nBy default, writes output to a folder named dist/ in the current project." + }, + "resourcesOutputPath": { + "type": "string", + "description": "The path where style resources will be placed, relative to outputPath." + }, + "aot": { + "type": "boolean", + "description": "Build using Ahead of Time compilation.", + "x-user-analytics": "ep.ng_aot", + "default": true + }, + "sourceMap": { + "description": "Output source maps for scripts and styles. For more information, see https://angular.io/guide/workspace-config#source-map-configuration.", + "default": false, + "oneOf": [ + { + "type": "object", + "properties": { + "scripts": { + "type": "boolean", + "description": "Output source maps for all scripts.", + "default": true + }, + "styles": { + "type": "boolean", + "description": "Output source maps for all styles.", + "default": true + }, + "hidden": { + "type": "boolean", + "description": "Output source maps used for error reporting tools.", + "default": false + }, + "vendor": { + "type": "boolean", + "description": "Resolve vendor packages source maps.", + "default": false + } + }, + "additionalProperties": false + }, + { + "type": "boolean" + } + ] + }, + "vendorChunk": { + "type": "boolean", + "description": "Generate a seperate bundle containing only vendor libraries. This option should only be used for development to reduce the incremental compilation time.", + "default": false + }, + "commonChunk": { + "type": "boolean", + "description": "Generate a seperate bundle containing code used across multiple bundles.", + "default": true + }, + "baseHref": { + "type": "string", + "description": "Base url for the application being built." + }, + "deployUrl": { + "type": "string", + "description": "URL where files will be deployed.", + "x-deprecated": "Use \"baseHref\" option, \"APP_BASE_HREF\" DI token or a combination of both instead. For more information, see https://angular.io/guide/deployment#the-deploy-url." + }, + "verbose": { + "type": "boolean", + "description": "Adds more details to output logging.", + "default": false + }, + "progress": { + "type": "boolean", + "description": "Log progress to the console while building.", + "default": true + }, + "i18nMissingTranslation": { + "type": "string", + "description": "How to handle missing translations for i18n.", + "enum": ["warning", "error", "ignore"], + "default": "warning" + }, + "i18nDuplicateTranslation": { + "type": "string", + "description": "How to handle duplicate translations for i18n.", + "enum": ["warning", "error", "ignore"], + "default": "warning" + }, + "localize": { + "description": "Translate the bundles in one or more locales.", + "oneOf": [ + { + "type": "boolean", + "description": "Translate all locales." + }, + { + "type": "array", + "description": "List of locales ID's to translate.", + "minItems": 1, + "items": { + "type": "string", + "pattern": "^[a-zA-Z]{2,3}(-[a-zA-Z]{4})?(-([a-zA-Z]{2}|[0-9]{3}))?(-[a-zA-Z]{5,8})?(-x(-[a-zA-Z0-9]{1,8})+)?$" + } + } + ] + }, + "watch": { + "type": "boolean", + "description": "Run build when files change.", + "default": false + }, + "outputHashing": { + "type": "string", + "description": "Define the output filename cache-busting hashing mode.", + "default": "none", + "enum": ["none", "all", "media", "bundles"] + }, + "poll": { + "type": "number", + "description": "Enable and define the file watching poll time period in milliseconds." + }, + "deleteOutputPath": { + "type": "boolean", + "description": "Delete the output path before building.", + "default": true + }, + "preserveSymlinks": { + "type": "boolean", + "description": "Do not use the real path when resolving modules. If unset then will default to `true` if NodeJS option --preserve-symlinks is set." + }, + "extractLicenses": { + "type": "boolean", + "description": "Extract all licenses in a separate file.", + "default": true + }, + "buildOptimizer": { + "type": "boolean", + "description": "Enables advanced build optimizations when using the 'aot' option.", + "default": true + }, + "namedChunks": { + "type": "boolean", + "description": "Use file name for lazy loaded chunks.", + "default": false + }, + "subresourceIntegrity": { + "type": "boolean", + "description": "Enables the use of subresource integrity validation.", + "default": false + }, + "serviceWorker": { + "type": "boolean", + "description": "Generates a service worker config for production builds.", + "default": false + }, + "ngswConfigPath": { + "type": "string", + "description": "Path to ngsw-config.json." + }, + "index": { + "description": "Configures the generation of the application's HTML index.", + "oneOf": [ + { + "type": "string", + "description": "The path of a file to use for the application's HTML index. The filename of the specified path will be used for the generated file and will be created in the root of the application's configured output path." + }, + { + "type": "object", + "description": "", + "properties": { + "input": { + "type": "string", + "minLength": 1, + "description": "The path of a file to use for the application's generated HTML index." + }, + "output": { + "type": "string", + "minLength": 1, + "default": "index.html", + "description": "The output path of the application's generated HTML index file. The full provided path will be used and will be considered relative to the application's configured output path." + } + }, + "required": ["input"] + }, + { + "const": false, + "description": "Does not generate an `index.html` file." + } + ] + }, + "statsJson": { + "type": "boolean", + "description": "Generates a 'stats.json' file which can be analyzed using tools such as 'webpack-bundle-analyzer'.", + "default": false + }, + "budgets": { + "description": "Budget thresholds to ensure parts of your application stay within boundaries which you set.", + "type": "array", + "items": { + "$ref": "#/definitions/budget" + }, + "default": [] + }, + "webWorkerTsConfig": { + "type": "string", + "description": "TypeScript configuration for Web Worker modules." + }, + "crossOrigin": { + "type": "string", + "description": "Define the crossorigin attribute setting of elements that provide CORS support.", + "default": "none", + "enum": ["none", "anonymous", "use-credentials"] + }, + "allowedCommonJsDependencies": { + "description": "A list of CommonJS packages that are allowed to be used without a build time warning.", + "type": "array", + "items": { + "type": "string" + }, + "default": [] + } + }, + "additionalProperties": false, + "required": ["outputPath", "index", "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": { + "type": "object", + "properties": { + "replace": { + "type": "string", + "pattern": "\\.(([cm]?j|t)sx?|json)$" + }, + "with": { + "type": "string", + "pattern": "\\.(([cm]?j|t)sx?|json)$" + } + }, + "additionalProperties": false, + "required": ["replace", "with"] + }, + "budget": { + "type": "object", + "properties": { + "type": { + "type": "string", + "description": "The type of budget.", + "enum": ["all", "allScript", "any", "anyScript", "anyComponentStyle", "bundle", "initial"] + }, + "name": { + "type": "string", + "description": "The name of the bundle." + }, + "baseline": { + "type": "string", + "description": "The baseline size for comparison." + }, + "maximumWarning": { + "type": "string", + "description": "The maximum threshold for warning relative to the baseline." + }, + "maximumError": { + "type": "string", + "description": "The maximum threshold for error relative to the baseline." + }, + "minimumWarning": { + "type": "string", + "description": "The minimum threshold for warning relative to the baseline." + }, + "minimumError": { + "type": "string", + "description": "The minimum threshold for error relative to the baseline." + }, + "warning": { + "type": "string", + "description": "The threshold for warning relative to the baseline (min & max)." + }, + "error": { + "type": "string", + "description": "The threshold for error relative to the baseline (min & max)." + } + }, + "additionalProperties": false, + "required": ["type"] + } + } +} diff --git a/artifacts/build-angular/src/builders/browser-esbuild/sourcemap-ignorelist-plugin.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/sourcemap-ignorelist-plugin.d.ts new file mode 100644 index 00000000..e48911e7 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/sourcemap-ignorelist-plugin.d.ts @@ -0,0 +1,17 @@ +/** + * @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 type { Plugin } from 'esbuild'; +/** + * Creates an esbuild plugin that updates generated sourcemaps to include the Chrome + * DevTools ignore list extension. All source files that originate from a node modules + * directory are added to the ignore list by this plugin. + * + * For more information, see https://developer.chrome.com/articles/x-google-ignore-list/ + * @returns An esbuild plugin. + */ +export declare function createSourcemapIngorelistPlugin(): Plugin; diff --git a/artifacts/build-angular/src/builders/browser-esbuild/sourcemap-ignorelist-plugin.js b/artifacts/build-angular/src/builders/browser-esbuild/sourcemap-ignorelist-plugin.js new file mode 100644 index 00000000..85a22d4e --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/sourcemap-ignorelist-plugin.js @@ -0,0 +1,68 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createSourcemapIngorelistPlugin = void 0; +/** + * The field identifier for the sourcemap Chrome Devtools ignore list extension. + * + * Following the naming conventions from https://sourcemaps.info/spec.html#h.ghqpj1ytqjbm + */ +const IGNORE_LIST_ID = 'x_google_ignoreList'; +/** + * Creates an esbuild plugin that updates generated sourcemaps to include the Chrome + * DevTools ignore list extension. All source files that originate from a node modules + * directory are added to the ignore list by this plugin. + * + * For more information, see https://developer.chrome.com/articles/x-google-ignore-list/ + * @returns An esbuild plugin. + */ +function createSourcemapIngorelistPlugin() { + return { + name: 'angular-sourcemap-ignorelist', + setup(build) { + if (!build.initialOptions.sourcemap) { + return; + } + build.onEnd((result) => { + if (!result.outputFiles) { + return; + } + for (const file of result.outputFiles) { + // Only process sourcemap files + if (!file.path.endsWith('.map')) { + continue; + } + const contents = Buffer.from(file.contents); + // Avoid parsing sourcemaps that have no node modules references + if (!contents.includes('node_modules/')) { + continue; + } + const map = JSON.parse(contents.toString('utf-8')); + const ignoreList = []; + // Check and store the index of each source originating from a node modules directory + for (let index = 0; index < map.sources.length; ++index) { + if (map.sources[index].startsWith('node_modules/') || + map.sources[index].includes('/node_modules/')) { + ignoreList.push(index); + } + } + // Avoid regenerating the source map if nothing changed + if (ignoreList.length === 0) { + continue; + } + // Update the sourcemap in the output file + map[IGNORE_LIST_ID] = ignoreList; + file.contents = Buffer.from(JSON.stringify(map), 'utf-8'); + } + }); + }, + }; +} +exports.createSourcemapIngorelistPlugin = createSourcemapIngorelistPlugin; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/bundle-options.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/bundle-options.d.ts new file mode 100644 index 00000000..37b38122 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/bundle-options.d.ts @@ -0,0 +1,53 @@ +/** + * @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 type { BuildOptions, OutputFile } from 'esbuild'; +import { LoadResultCache } from '../load-result-cache'; +export interface BundleStylesheetOptions { + workspaceRoot: string; + optimization: boolean; + preserveSymlinks?: boolean; + sourcemap: boolean | 'external' | 'inline'; + outputNames?: { + bundles?: string; + media?: string; + }; + includePaths?: string[]; + externalDependencies?: string[]; + target: string[]; + browsers: string[]; + tailwindConfiguration?: { + file: string; + package: string; + }; +} +export declare function createStylesheetBundleOptions(options: BundleStylesheetOptions, cache?: LoadResultCache, inlineComponentData?: Record): BuildOptions & { + plugins: NonNullable; +}; +/** + * Bundles a component stylesheet. The stylesheet can be either an inline stylesheet that + * is contained within the Component's metadata definition or an external file referenced + * from the Component's metadata definition. + * + * @param identifier A unique string identifier for the component stylesheet. + * @param language The language of the stylesheet such as `css` or `scss`. + * @param data The string content of the stylesheet. + * @param filename The filename representing the source of the stylesheet content. + * @param inline If true, the stylesheet source is within the component metadata; + * if false, the source is a stylesheet file. + * @param options An object containing the stylesheet bundling options. + * @returns An object containing the output of the bundling operation. + */ +export declare function bundleComponentStylesheet(language: string, data: string, filename: string, inline: boolean, options: BundleStylesheetOptions, cache?: LoadResultCache): Promise<{ + errors: import("esbuild").Message[] | undefined; + warnings: import("esbuild").Message[]; + contents: string; + map: string | undefined; + path: string | undefined; + resourceFiles: OutputFile[]; + metafile: import("esbuild").Metafile | undefined; +}>; diff --git a/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/bundle-options.js b/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/bundle-options.js new file mode 100644 index 00000000..5bdcd33e --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/bundle-options.js @@ -0,0 +1,159 @@ +"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 __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.bundleComponentStylesheet = exports.createStylesheetBundleOptions = void 0; +const node_path_1 = __importDefault(require("node:path")); +const esbuild_1 = require("../esbuild"); +const css_plugin_1 = require("./css-plugin"); +const css_resource_plugin_1 = require("./css-resource-plugin"); +const less_plugin_1 = require("./less-plugin"); +const sass_plugin_1 = require("./sass-plugin"); +/** + * A counter for component styles used to generate unique build-time identifiers for each stylesheet. + */ +let componentStyleCounter = 0; +function createStylesheetBundleOptions(options, cache, inlineComponentData) { + // Ensure preprocessor include paths are absolute based on the workspace root + const includePaths = options.includePaths?.map((includePath) => node_path_1.default.resolve(options.workspaceRoot, includePath)); + return { + absWorkingDir: options.workspaceRoot, + bundle: true, + entryNames: options.outputNames?.bundles, + assetNames: options.outputNames?.media, + logLevel: 'silent', + minify: options.optimization, + metafile: true, + sourcemap: options.sourcemap, + outdir: options.workspaceRoot, + write: false, + platform: 'browser', + target: options.target, + preserveSymlinks: options.preserveSymlinks, + external: options.externalDependencies, + conditions: ['style', 'sass'], + mainFields: ['style', 'sass'], + plugins: [ + (0, sass_plugin_1.createSassPlugin)({ + sourcemap: !!options.sourcemap, + loadPaths: includePaths, + inlineComponentData, + }, cache), + (0, less_plugin_1.createLessPlugin)({ + sourcemap: !!options.sourcemap, + includePaths, + inlineComponentData, + }), + (0, css_plugin_1.createCssPlugin)({ + sourcemap: !!options.sourcemap, + inlineComponentData, + browsers: options.browsers, + tailwindConfiguration: options.tailwindConfiguration, + }), + (0, css_resource_plugin_1.createCssResourcePlugin)(), + ], + }; +} +exports.createStylesheetBundleOptions = createStylesheetBundleOptions; +/** + * Bundles a component stylesheet. The stylesheet can be either an inline stylesheet that + * is contained within the Component's metadata definition or an external file referenced + * from the Component's metadata definition. + * + * @param identifier A unique string identifier for the component stylesheet. + * @param language The language of the stylesheet such as `css` or `scss`. + * @param data The string content of the stylesheet. + * @param filename The filename representing the source of the stylesheet content. + * @param inline If true, the stylesheet source is within the component metadata; + * if false, the source is a stylesheet file. + * @param options An object containing the stylesheet bundling options. + * @returns An object containing the output of the bundling operation. + */ +async function bundleComponentStylesheet(language, data, filename, inline, options, cache) { + const namespace = 'angular:styles/component'; + const entry = [language, componentStyleCounter++, filename].join(';'); + const buildOptions = createStylesheetBundleOptions(options, cache, { [entry]: data }); + buildOptions.entryPoints = [`${namespace};${entry}`]; + buildOptions.plugins.push({ + name: 'angular-component-styles', + setup(build) { + build.onResolve({ filter: /^angular:styles\/component;/ }, (args) => { + if (args.kind !== 'entry-point') { + return null; + } + if (inline) { + return { + path: entry, + namespace, + }; + } + else { + return { + path: filename, + }; + } + }); + build.onLoad({ filter: /^css;/, namespace }, async () => { + return { + contents: data, + loader: 'css', + resolveDir: node_path_1.default.dirname(filename), + }; + }); + }, + }); + // Execute esbuild + const context = new esbuild_1.BundlerContext(options.workspaceRoot, false, buildOptions); + const result = await context.bundle(); + // Extract the result of the bundling from the output files + let contents = ''; + let map; + let outputPath; + const resourceFiles = []; + if (!result.errors) { + for (const outputFile of result.outputFiles) { + const filename = node_path_1.default.basename(outputFile.path); + if (filename.endsWith('.css')) { + outputPath = outputFile.path; + contents = outputFile.text; + } + else if (filename.endsWith('.css.map')) { + map = outputFile.text; + } + else { + // The output files could also contain resources (images/fonts/etc.) that were referenced + resourceFiles.push(outputFile); + } + } + } + let metafile; + if (!result.errors) { + metafile = result.metafile; + // Remove entryPoint fields from outputs to prevent the internal component styles from being + // treated as initial files. Also mark the entry as a component resource for stat reporting. + Object.values(metafile.outputs).forEach((output) => { + delete output.entryPoint; + // eslint-disable-next-line @typescript-eslint/no-explicit-any + output['ng-component'] = true; + }); + } + return { + errors: result.errors, + warnings: result.warnings, + contents, + map, + path: outputPath, + resourceFiles, + metafile, + }; +} +exports.bundleComponentStylesheet = bundleComponentStylesheet; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bundle-options.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/stylesheets/bundle-options.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 type { BuildOptions, OutputFile } from 'esbuild';\nimport path from 'node:path';\nimport { BundlerContext } from '../esbuild';\nimport { LoadResultCache } from '../load-result-cache';\nimport { createCssPlugin } from './css-plugin';\nimport { createCssResourcePlugin } from './css-resource-plugin';\nimport { createLessPlugin } from './less-plugin';\nimport { createSassPlugin } from './sass-plugin';\n\n/**\n * A counter for component styles used to generate unique build-time identifiers for each stylesheet.\n */\nlet componentStyleCounter = 0;\n\nexport interface BundleStylesheetOptions {\n  workspaceRoot: string;\n  optimization: boolean;\n  preserveSymlinks?: boolean;\n  sourcemap: boolean | 'external' | 'inline';\n  outputNames?: { bundles?: string; media?: string };\n  includePaths?: string[];\n  externalDependencies?: string[];\n  target: string[];\n  browsers: string[];\n  tailwindConfiguration?: { file: string; package: string };\n}\n\nexport function createStylesheetBundleOptions(\n  options: BundleStylesheetOptions,\n  cache?: LoadResultCache,\n  inlineComponentData?: Record<string, string>,\n): BuildOptions & { plugins: NonNullable<BuildOptions['plugins']> } {\n  // Ensure preprocessor include paths are absolute based on the workspace root\n  const includePaths = options.includePaths?.map((includePath) =>\n    path.resolve(options.workspaceRoot, includePath),\n  );\n\n  return {\n    absWorkingDir: options.workspaceRoot,\n    bundle: true,\n    entryNames: options.outputNames?.bundles,\n    assetNames: options.outputNames?.media,\n    logLevel: 'silent',\n    minify: options.optimization,\n    metafile: true,\n    sourcemap: options.sourcemap,\n    outdir: options.workspaceRoot,\n    write: false,\n    platform: 'browser',\n    target: options.target,\n    preserveSymlinks: options.preserveSymlinks,\n    external: options.externalDependencies,\n    conditions: ['style', 'sass'],\n    mainFields: ['style', 'sass'],\n    plugins: [\n      createSassPlugin(\n        {\n          sourcemap: !!options.sourcemap,\n          loadPaths: includePaths,\n          inlineComponentData,\n        },\n        cache,\n      ),\n      createLessPlugin({\n        sourcemap: !!options.sourcemap,\n        includePaths,\n        inlineComponentData,\n      }),\n      createCssPlugin({\n        sourcemap: !!options.sourcemap,\n        inlineComponentData,\n        browsers: options.browsers,\n        tailwindConfiguration: options.tailwindConfiguration,\n      }),\n      createCssResourcePlugin(),\n    ],\n  };\n}\n\n/**\n * Bundles a component stylesheet. The stylesheet can be either an inline stylesheet that\n * is contained within the Component's metadata definition or an external file referenced\n * from the Component's metadata definition.\n *\n * @param identifier A unique string identifier for the component stylesheet.\n * @param language The language of the stylesheet such as `css` or `scss`.\n * @param data The string content of the stylesheet.\n * @param filename The filename representing the source of the stylesheet content.\n * @param inline If true, the stylesheet source is within the component metadata;\n * if false, the source is a stylesheet file.\n * @param options An object containing the stylesheet bundling options.\n * @returns An object containing the output of the bundling operation.\n */\nexport async function bundleComponentStylesheet(\n  language: string,\n  data: string,\n  filename: string,\n  inline: boolean,\n  options: BundleStylesheetOptions,\n  cache?: LoadResultCache,\n) {\n  const namespace = 'angular:styles/component';\n  const entry = [language, componentStyleCounter++, filename].join(';');\n\n  const buildOptions = createStylesheetBundleOptions(options, cache, { [entry]: data });\n  buildOptions.entryPoints = [`${namespace};${entry}`];\n  buildOptions.plugins.push({\n    name: 'angular-component-styles',\n    setup(build) {\n      build.onResolve({ filter: /^angular:styles\\/component;/ }, (args) => {\n        if (args.kind !== 'entry-point') {\n          return null;\n        }\n\n        if (inline) {\n          return {\n            path: entry,\n            namespace,\n          };\n        } else {\n          return {\n            path: filename,\n          };\n        }\n      });\n      build.onLoad({ filter: /^css;/, namespace }, async () => {\n        return {\n          contents: data,\n          loader: 'css',\n          resolveDir: path.dirname(filename),\n        };\n      });\n    },\n  });\n\n  // Execute esbuild\n  const context = new BundlerContext(options.workspaceRoot, false, buildOptions);\n  const result = await context.bundle();\n\n  // Extract the result of the bundling from the output files\n  let contents = '';\n  let map;\n  let outputPath;\n  const resourceFiles: OutputFile[] = [];\n  if (!result.errors) {\n    for (const outputFile of result.outputFiles) {\n      const filename = path.basename(outputFile.path);\n      if (filename.endsWith('.css')) {\n        outputPath = outputFile.path;\n        contents = outputFile.text;\n      } else if (filename.endsWith('.css.map')) {\n        map = outputFile.text;\n      } else {\n        // The output files could also contain resources (images/fonts/etc.) that were referenced\n        resourceFiles.push(outputFile);\n      }\n    }\n  }\n\n  let metafile;\n  if (!result.errors) {\n    metafile = result.metafile;\n    // Remove entryPoint fields from outputs to prevent the internal component styles from being\n    // treated as initial files. Also mark the entry as a component resource for stat reporting.\n    Object.values(metafile.outputs).forEach((output) => {\n      delete output.entryPoint;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      (output as any)['ng-component'] = true;\n    });\n  }\n\n  return {\n    errors: result.errors,\n    warnings: result.warnings,\n    contents,\n    map,\n    path: outputPath,\n    resourceFiles,\n    metafile,\n  };\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/css-plugin.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/css-plugin.d.ts new file mode 100644 index 00000000..f402d09b --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/css-plugin.d.ts @@ -0,0 +1,39 @@ +/** + * @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 type { Plugin } from 'esbuild'; +/** + * An object containing the plugin options to use when processing CSS stylesheets. + */ +export interface CssPluginOptions { + /** + * Controls the use and creation of sourcemaps when processing the stylesheets. + * If true, sourcemap processing is enabled; if false, disabled. + */ + sourcemap: boolean; + /** + * Optional component data for any inline styles from Component decorator `styles` fields. + * The key is an internal angular resource URI and the value is the stylesheet content. + */ + inlineComponentData?: Record; + /** + * The browsers to support in browserslist format when processing stylesheets. + * Some postcss plugins such as autoprefixer require the raw browserslist information instead + * of the esbuild formatted target. + */ + browsers: string[]; + tailwindConfiguration?: { + file: string; + package: string; + }; +} +/** + * Creates an esbuild plugin to process CSS stylesheets. + * @param options An object containing the plugin options. + * @returns An esbuild Plugin instance. + */ +export declare function createCssPlugin(options: CssPluginOptions): Plugin; diff --git a/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/css-plugin.js b/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/css-plugin.js new file mode 100644 index 00000000..843b94c5 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/css-plugin.js @@ -0,0 +1,164 @@ +"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; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createCssPlugin = void 0; +const autoprefixer_1 = __importDefault(require("autoprefixer")); +const node_assert_1 = __importDefault(require("node:assert")); +const promises_1 = require("node:fs/promises"); +/** + * The lazy-loaded instance of the postcss stylesheet postprocessor. + * It is only imported and initialized if postcss is needed. + */ +let postcss; +/** + * Creates an esbuild plugin to process CSS stylesheets. + * @param options An object containing the plugin options. + * @returns An esbuild Plugin instance. + */ +function createCssPlugin(options) { + return { + name: 'angular-css', + async setup(build) { + const autoprefixer = (0, autoprefixer_1.default)({ + overrideBrowserslist: options.browsers, + ignoreUnknownVersions: true, + }); + // Autoprefixer currently does not contain a method to check if autoprefixer is required + // based on the provided list of browsers. However, it does contain a method that returns + // informational text that can be used as a replacement. The text "Awesome!" will be present + // when autoprefixer determines no actions are needed. + // ref: https://github.com/postcss/autoprefixer/blob/e2f5c26ff1f3eaca95a21873723ce1cdf6e59f0e/lib/info.js#L118 + const autoprefixerInfo = autoprefixer.info({ from: build.initialOptions.absWorkingDir }); + const skipAutoprefixer = autoprefixerInfo.includes('Awesome!'); + if (skipAutoprefixer && !options.tailwindConfiguration) { + return; + } + postcss ?? (postcss = (await Promise.resolve().then(() => __importStar(require('postcss')))).default); + const postcssProcessor = postcss(); + if (options.tailwindConfiguration) { + const tailwind = await Promise.resolve(`${options.tailwindConfiguration.package}`).then(s => __importStar(require(s))); + postcssProcessor.use(tailwind.default({ config: options.tailwindConfiguration.file })); + } + if (!skipAutoprefixer) { + postcssProcessor.use(autoprefixer); + } + // Add a load callback to support inline Component styles + build.onLoad({ filter: /^css;/, namespace: 'angular:styles/component' }, async (args) => { + const data = options.inlineComponentData?.[args.path]; + (0, node_assert_1.default)(typeof data === 'string', `component style name should always be found [${args.path}]`); + const [, , filePath] = args.path.split(';', 3); + return compileString(data, filePath, postcssProcessor, options); + }); + // Add a load callback to support files from disk + build.onLoad({ filter: /\.css$/ }, async (args) => { + const data = await (0, promises_1.readFile)(args.path, 'utf-8'); + return compileString(data, args.path, postcssProcessor, options); + }); + }, + }; +} +exports.createCssPlugin = createCssPlugin; +/** + * Compiles the provided CSS stylesheet data using a provided postcss processor and provides an + * esbuild load result that can be used directly by an esbuild Plugin. + * @param data The stylesheet content to process. + * @param filename The name of the file that contains the data. + * @param postcssProcessor A postcss processor instance to use. + * @param options The plugin options to control the processing. + * @returns An esbuild OnLoaderResult object with the processed content, warnings, and/or errors. + */ +async function compileString(data, filename, postcssProcessor, options) { + try { + const result = await postcssProcessor.process(data, { + from: filename, + to: filename, + map: options.sourcemap && { + inline: true, + sourcesContent: true, + }, + }); + const rawWarnings = result.warnings(); + let warnings; + if (rawWarnings.length > 0) { + const lineMappings = new Map(); + warnings = rawWarnings.map((warning) => { + const file = warning.node.source?.input.file; + if (file === undefined) { + return { text: warning.text }; + } + let lines = lineMappings.get(file); + if (lines === undefined) { + lines = warning.node.source?.input.css.split(/\r?\n/); + lineMappings.set(file, lines ?? null); + } + return { + text: warning.text, + location: { + file, + line: warning.line, + column: warning.column - 1, + lineText: lines?.[warning.line - 1], + }, + }; + }); + } + return { + contents: result.css, + loader: 'css', + warnings, + }; + } + catch (error) { + postcss ?? (postcss = (await Promise.resolve().then(() => __importStar(require('postcss')))).default); + if (error instanceof postcss.CssSyntaxError) { + const lines = error.source?.split(/\r?\n/); + return { + errors: [ + { + text: error.reason, + location: { + file: error.file, + line: error.line, + column: error.column && error.column - 1, + lineText: error.line === undefined ? undefined : lines?.[error.line - 1], + }, + }, + ], + }; + } + throw error; + } +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"css-plugin.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/stylesheets/css-plugin.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 createAutoPrefixerPlugin from 'autoprefixer';\nimport type { OnLoadResult, Plugin, PluginBuild } from 'esbuild';\nimport assert from 'node:assert';\nimport { readFile } from 'node:fs/promises';\n\n/**\n * The lazy-loaded instance of the postcss stylesheet postprocessor.\n * It is only imported and initialized if postcss is needed.\n */\nlet postcss: typeof import('postcss')['default'] | undefined;\n\n/**\n * An object containing the plugin options to use when processing CSS stylesheets.\n */\nexport interface CssPluginOptions {\n  /**\n   * Controls the use and creation of sourcemaps when processing the stylesheets.\n   * If true, sourcemap processing is enabled; if false, disabled.\n   */\n  sourcemap: boolean;\n  /**\n   * Optional component data for any inline styles from Component decorator `styles` fields.\n   * The key is an internal angular resource URI and the value is the stylesheet content.\n   */\n  inlineComponentData?: Record<string, string>;\n  /**\n   * The browsers to support in browserslist format when processing stylesheets.\n   * Some postcss plugins such as autoprefixer require the raw browserslist information instead\n   * of the esbuild formatted target.\n   */\n  browsers: string[];\n\n  tailwindConfiguration?: { file: string; package: string };\n}\n\n/**\n * Creates an esbuild plugin to process CSS stylesheets.\n * @param options An object containing the plugin options.\n * @returns An esbuild Plugin instance.\n */\nexport function createCssPlugin(options: CssPluginOptions): Plugin {\n  return {\n    name: 'angular-css',\n    async setup(build: PluginBuild): Promise<void> {\n      const autoprefixer = createAutoPrefixerPlugin({\n        overrideBrowserslist: options.browsers,\n        ignoreUnknownVersions: true,\n      });\n\n      // Autoprefixer currently does not contain a method to check if autoprefixer is required\n      // based on the provided list of browsers. However, it does contain a method that returns\n      // informational text that can be used as a replacement. The text \"Awesome!\" will be present\n      // when autoprefixer determines no actions are needed.\n      // ref: https://github.com/postcss/autoprefixer/blob/e2f5c26ff1f3eaca95a21873723ce1cdf6e59f0e/lib/info.js#L118\n      const autoprefixerInfo = autoprefixer.info({ from: build.initialOptions.absWorkingDir });\n      const skipAutoprefixer = autoprefixerInfo.includes('Awesome!');\n\n      if (skipAutoprefixer && !options.tailwindConfiguration) {\n        return;\n      }\n\n      postcss ??= (await import('postcss')).default;\n      const postcssProcessor = postcss();\n      if (options.tailwindConfiguration) {\n        const tailwind = await import(options.tailwindConfiguration.package);\n        postcssProcessor.use(tailwind.default({ config: options.tailwindConfiguration.file }));\n      }\n      if (!skipAutoprefixer) {\n        postcssProcessor.use(autoprefixer);\n      }\n\n      // Add a load callback to support inline Component styles\n      build.onLoad({ filter: /^css;/, namespace: 'angular:styles/component' }, async (args) => {\n        const data = options.inlineComponentData?.[args.path];\n        assert(\n          typeof data === 'string',\n          `component style name should always be found [${args.path}]`,\n        );\n\n        const [, , filePath] = args.path.split(';', 3);\n\n        return compileString(data, filePath, postcssProcessor, options);\n      });\n\n      // Add a load callback to support files from disk\n      build.onLoad({ filter: /\\.css$/ }, async (args) => {\n        const data = await readFile(args.path, 'utf-8');\n\n        return compileString(data, args.path, postcssProcessor, options);\n      });\n    },\n  };\n}\n\n/**\n * Compiles the provided CSS stylesheet data using a provided postcss processor and provides an\n * esbuild load result that can be used directly by an esbuild Plugin.\n * @param data The stylesheet content to process.\n * @param filename The name of the file that contains the data.\n * @param postcssProcessor A postcss processor instance to use.\n * @param options The plugin options to control the processing.\n * @returns An esbuild OnLoaderResult object with the processed content, warnings, and/or errors.\n */\nasync function compileString(\n  data: string,\n  filename: string,\n  postcssProcessor: import('postcss').Processor,\n  options: CssPluginOptions,\n): Promise<OnLoadResult> {\n  try {\n    const result = await postcssProcessor.process(data, {\n      from: filename,\n      to: filename,\n      map: options.sourcemap && {\n        inline: true,\n        sourcesContent: true,\n      },\n    });\n\n    const rawWarnings = result.warnings();\n    let warnings;\n    if (rawWarnings.length > 0) {\n      const lineMappings = new Map<string, string[] | null>();\n      warnings = rawWarnings.map((warning) => {\n        const file = warning.node.source?.input.file;\n        if (file === undefined) {\n          return { text: warning.text };\n        }\n\n        let lines = lineMappings.get(file);\n        if (lines === undefined) {\n          lines = warning.node.source?.input.css.split(/\\r?\\n/);\n          lineMappings.set(file, lines ?? null);\n        }\n\n        return {\n          text: warning.text,\n          location: {\n            file,\n            line: warning.line,\n            column: warning.column - 1,\n            lineText: lines?.[warning.line - 1],\n          },\n        };\n      });\n    }\n\n    return {\n      contents: result.css,\n      loader: 'css',\n      warnings,\n    };\n  } catch (error) {\n    postcss ??= (await import('postcss')).default;\n    if (error instanceof postcss.CssSyntaxError) {\n      const lines = error.source?.split(/\\r?\\n/);\n\n      return {\n        errors: [\n          {\n            text: error.reason,\n            location: {\n              file: error.file,\n              line: error.line,\n              column: error.column && error.column - 1,\n              lineText: error.line === undefined ? undefined : lines?.[error.line - 1],\n            },\n          },\n        ],\n      };\n    }\n\n    throw error;\n  }\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/css-resource-plugin.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/css-resource-plugin.d.ts new file mode 100644 index 00000000..6c7ecaa3 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/css-resource-plugin.d.ts @@ -0,0 +1,17 @@ +/** + * @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 type { Plugin } from 'esbuild'; +/** + * Creates an esbuild {@link Plugin} that loads all CSS url token references using the + * built-in esbuild `file` loader. A plugin is used to allow for all file extensions + * and types to be supported without needing to manually specify all extensions + * within the build configuration. + * + * @returns An esbuild {@link Plugin} instance. + */ +export declare function createCssResourcePlugin(): Plugin; diff --git a/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/css-resource-plugin.js b/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/css-resource-plugin.js new file mode 100644 index 00000000..b90843ea --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/css-resource-plugin.js @@ -0,0 +1,77 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createCssResourcePlugin = void 0; +const promises_1 = require("node:fs/promises"); +const node_path_1 = require("node:path"); +/** + * Symbol marker used to indicate CSS resource resolution is being attempted. + * This is used to prevent an infinite loop within the plugin's resolve hook. + */ +const CSS_RESOURCE_RESOLUTION = Symbol('CSS_RESOURCE_RESOLUTION'); +/** + * Creates an esbuild {@link Plugin} that loads all CSS url token references using the + * built-in esbuild `file` loader. A plugin is used to allow for all file extensions + * and types to be supported without needing to manually specify all extensions + * within the build configuration. + * + * @returns An esbuild {@link Plugin} instance. + */ +function createCssResourcePlugin() { + return { + name: 'angular-css-resource', + setup(build) { + build.onResolve({ filter: /.*/ }, async (args) => { + // Only attempt to resolve url tokens which only exist inside CSS. + // Also, skip this plugin if already attempting to resolve the url-token. + if (args.kind !== 'url-token' || args.pluginData?.[CSS_RESOURCE_RESOLUTION]) { + return null; + } + // If root-relative, absolute or protocol relative url, mark as external to leave the + // path/URL in place. + if (/^((?:\w+:)?\/\/|data:|chrome:|#|\/)/.test(args.path)) { + return { + path: args.path, + external: true, + }; + } + const { importer, kind, resolveDir, namespace, pluginData = {} } = args; + pluginData[CSS_RESOURCE_RESOLUTION] = true; + const result = await build.resolve(args.path, { + importer, + kind, + namespace, + pluginData, + resolveDir, + }); + // Return results that are not files since these are most likely specific to another plugin + // and cannot be loaded by this plugin. + if (result.namespace !== 'file' || !result.path) { + return result; + } + // All file results are considered CSS resources and will be loaded via the file loader + return { + ...result, + // Use a relative path to prevent fully resolved paths in the metafile (JSON stats file). + // This is only necessary for custom namespaces. esbuild will handle the file namespace. + path: (0, node_path_1.relative)(build.initialOptions.absWorkingDir ?? '', result.path), + namespace: 'css-resource', + }; + }); + build.onLoad({ filter: /.*/, namespace: 'css-resource' }, async (args) => { + return { + contents: await (0, promises_1.readFile)((0, node_path_1.join)(build.initialOptions.absWorkingDir ?? '', args.path)), + loader: 'file', + }; + }); + }, + }; +} +exports.createCssResourcePlugin = createCssResourcePlugin; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3NzLXJlc291cmNlLXBsdWdpbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2FuZ3VsYXJfZGV2a2l0L2J1aWxkX2FuZ3VsYXIvc3JjL2J1aWxkZXJzL2Jyb3dzZXItZXNidWlsZC9zdHlsZXNoZWV0cy9jc3MtcmVzb3VyY2UtcGx1Z2luLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7O0dBTUc7OztBQUdILCtDQUE0QztBQUM1Qyx5Q0FBMkM7QUFFM0M7OztHQUdHO0FBQ0gsTUFBTSx1QkFBdUIsR0FBRyxNQUFNLENBQUMseUJBQXlCLENBQUMsQ0FBQztBQUVsRTs7Ozs7OztHQU9HO0FBQ0gsU0FBZ0IsdUJBQXVCO0lBQ3JDLE9BQU87UUFDTCxJQUFJLEVBQUUsc0JBQXNCO1FBQzVCLEtBQUssQ0FBQyxLQUFrQjtZQUN0QixLQUFLLENBQUMsU0FBUyxDQUFDLEVBQUUsTUFBTSxFQUFFLElBQUksRUFBRSxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsRUFBRTtnQkFDL0Msa0VBQWtFO2dCQUNsRSx5RUFBeUU7Z0JBQ3pFLElBQUksSUFBSSxDQUFDLElBQUksS0FBSyxXQUFXLElBQUksSUFBSSxDQUFDLFVBQVUsRUFBRSxDQUFDLHVCQUF1QixDQUFDLEVBQUU7b0JBQzNFLE9BQU8sSUFBSSxDQUFDO2lCQUNiO2dCQUVELHFGQUFxRjtnQkFDckYscUJBQXFCO2dCQUNyQixJQUFJLHFDQUFxQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUU7b0JBQ3pELE9BQU87d0JBQ0wsSUFBSSxFQUFFLElBQUksQ0FBQyxJQUFJO3dCQUNmLFFBQVEsRUFBRSxJQUFJO3FCQUNmLENBQUM7aUJBQ0g7Z0JBRUQsTUFBTSxFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUUsVUFBVSxFQUFFLFNBQVMsRUFBRSxVQUFVLEdBQUcsRUFBRSxFQUFFLEdBQUcsSUFBSSxDQUFDO2dCQUN4RSxVQUFVLENBQUMsdUJBQXVCLENBQUMsR0FBRyxJQUFJLENBQUM7Z0JBRTNDLE1BQU0sTUFBTSxHQUFHLE1BQU0sS0FBSyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFO29CQUM1QyxRQUFRO29CQUNSLElBQUk7b0JBQ0osU0FBUztvQkFDVCxVQUFVO29CQUNWLFVBQVU7aUJBQ1gsQ0FBQyxDQUFDO2dCQUVILDJGQUEyRjtnQkFDM0YsdUNBQXVDO2dCQUN2QyxJQUFJLE1BQU0sQ0FBQyxTQUFTLEtBQUssTUFBTSxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksRUFBRTtvQkFDL0MsT0FBTyxNQUFNLENBQUM7aUJBQ2Y7Z0JBRUQsdUZBQXVGO2dCQUN2RixPQUFPO29CQUNMLEdBQUcsTUFBTTtvQkFDVCx5RkFBeUY7b0JBQ3pGLHdGQUF3RjtvQkFDeEYsSUFBSSxFQUFFLElBQUEsb0JBQVEsRUFBQyxLQUFLLENBQUMsY0FBYyxDQUFDLGFBQWEsSUFBSSxFQUFFLEVBQUUsTUFBTSxDQUFDLElBQUksQ0FBQztvQkFDckUsU0FBUyxFQUFFLGNBQWM7aUJBQzFCLENBQUM7WUFDSixDQUFDLENBQUMsQ0FBQztZQUVILEtBQUssQ0FBQyxNQUFNLENBQUMsRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLFNBQVMsRUFBRSxjQUFjLEVBQUUsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLEVBQUU7Z0JBQ3ZFLE9BQU87b0JBQ0wsUUFBUSxFQUFFLE1BQU0sSUFBQSxtQkFBUSxFQUFDLElBQUEsZ0JBQUksRUFBQyxLQUFLLENBQUMsY0FBYyxDQUFDLGFBQWEsSUFBSSxFQUFFLEVBQUUsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO29CQUNuRixNQUFNLEVBQUUsTUFBTTtpQkFDZixDQUFDO1lBQ0osQ0FBQyxDQUFDLENBQUM7UUFDTCxDQUFDO0tBQ0YsQ0FBQztBQUNKLENBQUM7QUF2REQsMERBdURDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCB0eXBlIHsgUGx1Z2luLCBQbHVnaW5CdWlsZCB9IGZyb20gJ2VzYnVpbGQnO1xuaW1wb3J0IHsgcmVhZEZpbGUgfSBmcm9tICdub2RlOmZzL3Byb21pc2VzJztcbmltcG9ydCB7IGpvaW4sIHJlbGF0aXZlIH0gZnJvbSAnbm9kZTpwYXRoJztcblxuLyoqXG4gKiBTeW1ib2wgbWFya2VyIHVzZWQgdG8gaW5kaWNhdGUgQ1NTIHJlc291cmNlIHJlc29sdXRpb24gaXMgYmVpbmcgYXR0ZW1wdGVkLlxuICogVGhpcyBpcyB1c2VkIHRvIHByZXZlbnQgYW4gaW5maW5pdGUgbG9vcCB3aXRoaW4gdGhlIHBsdWdpbidzIHJlc29sdmUgaG9vay5cbiAqL1xuY29uc3QgQ1NTX1JFU09VUkNFX1JFU09MVVRJT04gPSBTeW1ib2woJ0NTU19SRVNPVVJDRV9SRVNPTFVUSU9OJyk7XG5cbi8qKlxuICogQ3JlYXRlcyBhbiBlc2J1aWxkIHtAbGluayBQbHVnaW59IHRoYXQgbG9hZHMgYWxsIENTUyB1cmwgdG9rZW4gcmVmZXJlbmNlcyB1c2luZyB0aGVcbiAqIGJ1aWx0LWluIGVzYnVpbGQgYGZpbGVgIGxvYWRlci4gQSBwbHVnaW4gaXMgdXNlZCB0byBhbGxvdyBmb3IgYWxsIGZpbGUgZXh0ZW5zaW9uc1xuICogYW5kIHR5cGVzIHRvIGJlIHN1cHBvcnRlZCB3aXRob3V0IG5lZWRpbmcgdG8gbWFudWFsbHkgc3BlY2lmeSBhbGwgZXh0ZW5zaW9uc1xuICogd2l0aGluIHRoZSBidWlsZCBjb25maWd1cmF0aW9uLlxuICpcbiAqIEByZXR1cm5zIEFuIGVzYnVpbGQge0BsaW5rIFBsdWdpbn0gaW5zdGFuY2UuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjcmVhdGVDc3NSZXNvdXJjZVBsdWdpbigpOiBQbHVnaW4ge1xuICByZXR1cm4ge1xuICAgIG5hbWU6ICdhbmd1bGFyLWNzcy1yZXNvdXJjZScsXG4gICAgc2V0dXAoYnVpbGQ6IFBsdWdpbkJ1aWxkKTogdm9pZCB7XG4gICAgICBidWlsZC5vblJlc29sdmUoeyBmaWx0ZXI6IC8uKi8gfSwgYXN5bmMgKGFyZ3MpID0+IHtcbiAgICAgICAgLy8gT25seSBhdHRlbXB0IHRvIHJlc29sdmUgdXJsIHRva2VucyB3aGljaCBvbmx5IGV4aXN0IGluc2lkZSBDU1MuXG4gICAgICAgIC8vIEFsc28sIHNraXAgdGhpcyBwbHVnaW4gaWYgYWxyZWFkeSBhdHRlbXB0aW5nIHRvIHJlc29sdmUgdGhlIHVybC10b2tlbi5cbiAgICAgICAgaWYgKGFyZ3Mua2luZCAhPT0gJ3VybC10b2tlbicgfHwgYXJncy5wbHVnaW5EYXRhPy5bQ1NTX1JFU09VUkNFX1JFU09MVVRJT05dKSB7XG4gICAgICAgICAgcmV0dXJuIG51bGw7XG4gICAgICAgIH1cblxuICAgICAgICAvLyBJZiByb290LXJlbGF0aXZlLCBhYnNvbHV0ZSBvciBwcm90b2NvbCByZWxhdGl2ZSB1cmwsIG1hcmsgYXMgZXh0ZXJuYWwgdG8gbGVhdmUgdGhlXG4gICAgICAgIC8vIHBhdGgvVVJMIGluIHBsYWNlLlxuICAgICAgICBpZiAoL14oKD86XFx3KzopP1xcL1xcL3xkYXRhOnxjaHJvbWU6fCN8XFwvKS8udGVzdChhcmdzLnBhdGgpKSB7XG4gICAgICAgICAgcmV0dXJuIHtcbiAgICAgICAgICAgIHBhdGg6IGFyZ3MucGF0aCxcbiAgICAgICAgICAgIGV4dGVybmFsOiB0cnVlLFxuICAgICAgICAgIH07XG4gICAgICAgIH1cblxuICAgICAgICBjb25zdCB7IGltcG9ydGVyLCBraW5kLCByZXNvbHZlRGlyLCBuYW1lc3BhY2UsIHBsdWdpbkRhdGEgPSB7fSB9ID0gYXJncztcbiAgICAgICAgcGx1Z2luRGF0YVtDU1NfUkVTT1VSQ0VfUkVTT0xVVElPTl0gPSB0cnVlO1xuXG4gICAgICAgIGNvbnN0IHJlc3VsdCA9IGF3YWl0IGJ1aWxkLnJlc29sdmUoYXJncy5wYXRoLCB7XG4gICAgICAgICAgaW1wb3J0ZXIsXG4gICAgICAgICAga2luZCxcbiAgICAgICAgICBuYW1lc3BhY2UsXG4gICAgICAgICAgcGx1Z2luRGF0YSxcbiAgICAgICAgICByZXNvbHZlRGlyLFxuICAgICAgICB9KTtcblxuICAgICAgICAvLyBSZXR1cm4gcmVzdWx0cyB0aGF0IGFyZSBub3QgZmlsZXMgc2luY2UgdGhlc2UgYXJlIG1vc3QgbGlrZWx5IHNwZWNpZmljIHRvIGFub3RoZXIgcGx1Z2luXG4gICAgICAgIC8vIGFuZCBjYW5ub3QgYmUgbG9hZGVkIGJ5IHRoaXMgcGx1Z2luLlxuICAgICAgICBpZiAocmVzdWx0Lm5hbWVzcGFjZSAhPT0gJ2ZpbGUnIHx8ICFyZXN1bHQucGF0aCkge1xuICAgICAgICAgIHJldHVybiByZXN1bHQ7XG4gICAgICAgIH1cblxuICAgICAgICAvLyBBbGwgZmlsZSByZXN1bHRzIGFyZSBjb25zaWRlcmVkIENTUyByZXNvdXJjZXMgYW5kIHdpbGwgYmUgbG9hZGVkIHZpYSB0aGUgZmlsZSBsb2FkZXJcbiAgICAgICAgcmV0dXJuIHtcbiAgICAgICAgICAuLi5yZXN1bHQsXG4gICAgICAgICAgLy8gVXNlIGEgcmVsYXRpdmUgcGF0aCB0byBwcmV2ZW50IGZ1bGx5IHJlc29sdmVkIHBhdGhzIGluIHRoZSBtZXRhZmlsZSAoSlNPTiBzdGF0cyBmaWxlKS5cbiAgICAgICAgICAvLyBUaGlzIGlzIG9ubHkgbmVjZXNzYXJ5IGZvciBjdXN0b20gbmFtZXNwYWNlcy4gZXNidWlsZCB3aWxsIGhhbmRsZSB0aGUgZmlsZSBuYW1lc3BhY2UuXG4gICAgICAgICAgcGF0aDogcmVsYXRpdmUoYnVpbGQuaW5pdGlhbE9wdGlvbnMuYWJzV29ya2luZ0RpciA/PyAnJywgcmVzdWx0LnBhdGgpLFxuICAgICAgICAgIG5hbWVzcGFjZTogJ2Nzcy1yZXNvdXJjZScsXG4gICAgICAgIH07XG4gICAgICB9KTtcblxuICAgICAgYnVpbGQub25Mb2FkKHsgZmlsdGVyOiAvLiovLCBuYW1lc3BhY2U6ICdjc3MtcmVzb3VyY2UnIH0sIGFzeW5jIChhcmdzKSA9PiB7XG4gICAgICAgIHJldHVybiB7XG4gICAgICAgICAgY29udGVudHM6IGF3YWl0IHJlYWRGaWxlKGpvaW4oYnVpbGQuaW5pdGlhbE9wdGlvbnMuYWJzV29ya2luZ0RpciA/PyAnJywgYXJncy5wYXRoKSksXG4gICAgICAgICAgbG9hZGVyOiAnZmlsZScsXG4gICAgICAgIH07XG4gICAgICB9KTtcbiAgICB9LFxuICB9O1xufVxuIl19 \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/less-plugin.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/less-plugin.d.ts new file mode 100644 index 00000000..9013e086 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/less-plugin.d.ts @@ -0,0 +1,14 @@ +/** + * @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 type { Plugin } from 'esbuild'; +export interface LessPluginOptions { + sourcemap: boolean; + includePaths?: string[]; + inlineComponentData?: Record; +} +export declare function createLessPlugin(options: LessPluginOptions): Plugin; diff --git a/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/less-plugin.js b/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/less-plugin.js new file mode 100644 index 00000000..9391b943 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/less-plugin.js @@ -0,0 +1,142 @@ +"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; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createLessPlugin = void 0; +const node_assert_1 = __importDefault(require("node:assert")); +const promises_1 = require("node:fs/promises"); +/** + * The lazy-loaded instance of the less stylesheet preprocessor. + * It is only imported and initialized if a less stylesheet is used. + */ +let lessPreprocessor; +function isLessException(error) { + return !!error && typeof error === 'object' && 'column' in error; +} +function createLessPlugin(options) { + return { + name: 'angular-less', + setup(build) { + // Add a load callback to support inline Component styles + build.onLoad({ filter: /^less;/, namespace: 'angular:styles/component' }, async (args) => { + const data = options.inlineComponentData?.[args.path]; + (0, node_assert_1.default)(typeof data === 'string', `component style name should always be found [${args.path}]`); + const [, , filePath] = args.path.split(';', 3); + return compileString(data, filePath, options, build.resolve.bind(build)); + }); + // Add a load callback to support files from disk + build.onLoad({ filter: /\.less$/ }, async (args) => { + const data = await (0, promises_1.readFile)(args.path, 'utf-8'); + return compileString(data, args.path, options, build.resolve.bind(build)); + }); + }, + }; +} +exports.createLessPlugin = createLessPlugin; +async function compileString(data, filename, options, resolver) { + const less = (lessPreprocessor ?? (lessPreprocessor = (await Promise.resolve().then(() => __importStar(require('less')))).default)); + const resolverPlugin = { + install({ FileManager }, pluginManager) { + const resolverFileManager = new (class extends FileManager { + supportsSync() { + return false; + } + supports() { + return true; + } + async loadFile(filename, currentDirectory, options, environment) { + // Attempt direct loading as a relative path to avoid resolution overhead + try { + return await super.loadFile(filename, currentDirectory, options, environment); + } + catch (error) { + // Attempt a full resolution if not found + const fullResult = await resolver(filename, { + kind: 'import-rule', + resolveDir: currentDirectory, + }); + if (fullResult.path) { + return { + filename: fullResult.path, + contents: await (0, promises_1.readFile)(fullResult.path, 'utf-8'), + }; + } + // Otherwise error by throwing the failing direct result + throw error; + } + } + })(); + pluginManager.addFileManager(resolverFileManager); + }, + }; + try { + const result = await less.render(data, { + filename, + paths: options.includePaths, + plugins: [resolverPlugin], + rewriteUrls: 'all', + sourceMap: options.sourcemap + ? { + sourceMapFileInline: true, + outputSourceFiles: true, + } + : undefined, + }); + return { + contents: result.css, + loader: 'css', + }; + } + catch (error) { + if (isLessException(error)) { + return { + errors: [ + { + text: error.message, + location: { + file: error.filename, + line: error.line, + column: error.column, + // Middle element represents the line containing the error + lineText: error.extract && error.extract[Math.trunc(error.extract.length / 2)], + }, + }, + ], + loader: 'css', + }; + } + throw error; + } +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"less-plugin.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/stylesheets/less-plugin.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 type { OnLoadResult, Plugin, PluginBuild } from 'esbuild';\nimport assert from 'node:assert';\nimport { readFile } from 'node:fs/promises';\n\n/**\n * The lazy-loaded instance of the less stylesheet preprocessor.\n * It is only imported and initialized if a less stylesheet is used.\n */\nlet lessPreprocessor: typeof import('less') | undefined;\n\nexport interface LessPluginOptions {\n  sourcemap: boolean;\n  includePaths?: string[];\n  inlineComponentData?: Record<string, string>;\n}\n\ninterface LessException extends Error {\n  filename: string;\n  line: number;\n  column: number;\n  extract?: string[];\n}\n\nfunction isLessException(error: unknown): error is LessException {\n  return !!error && typeof error === 'object' && 'column' in error;\n}\n\nexport function createLessPlugin(options: LessPluginOptions): Plugin {\n  return {\n    name: 'angular-less',\n    setup(build: PluginBuild): void {\n      // Add a load callback to support inline Component styles\n      build.onLoad({ filter: /^less;/, namespace: 'angular:styles/component' }, async (args) => {\n        const data = options.inlineComponentData?.[args.path];\n        assert(\n          typeof data === 'string',\n          `component style name should always be found [${args.path}]`,\n        );\n\n        const [, , filePath] = args.path.split(';', 3);\n\n        return compileString(data, filePath, options, build.resolve.bind(build));\n      });\n\n      // Add a load callback to support files from disk\n      build.onLoad({ filter: /\\.less$/ }, async (args) => {\n        const data = await readFile(args.path, 'utf-8');\n\n        return compileString(data, args.path, options, build.resolve.bind(build));\n      });\n    },\n  };\n}\n\nasync function compileString(\n  data: string,\n  filename: string,\n  options: LessPluginOptions,\n  resolver: PluginBuild['resolve'],\n): Promise<OnLoadResult> {\n  const less = (lessPreprocessor ??= (await import('less')).default);\n\n  const resolverPlugin: Less.Plugin = {\n    install({ FileManager }, pluginManager): void {\n      const resolverFileManager = new (class extends FileManager {\n        override supportsSync(): boolean {\n          return false;\n        }\n\n        override supports(): boolean {\n          return true;\n        }\n\n        override async loadFile(\n          filename: string,\n          currentDirectory: string,\n          options: Less.LoadFileOptions,\n          environment: Less.Environment,\n        ): Promise<Less.FileLoadResult> {\n          // Attempt direct loading as a relative path to avoid resolution overhead\n          try {\n            return await super.loadFile(filename, currentDirectory, options, environment);\n          } catch (error) {\n            // Attempt a full resolution if not found\n            const fullResult = await resolver(filename, {\n              kind: 'import-rule',\n              resolveDir: currentDirectory,\n            });\n            if (fullResult.path) {\n              return {\n                filename: fullResult.path,\n                contents: await readFile(fullResult.path, 'utf-8'),\n              };\n            }\n            // Otherwise error by throwing the failing direct result\n            throw error;\n          }\n        }\n      })();\n\n      pluginManager.addFileManager(resolverFileManager);\n    },\n  };\n\n  try {\n    const result = await less.render(data, {\n      filename,\n      paths: options.includePaths,\n      plugins: [resolverPlugin],\n      rewriteUrls: 'all',\n      sourceMap: options.sourcemap\n        ? {\n            sourceMapFileInline: true,\n            outputSourceFiles: true,\n          }\n        : undefined,\n    } as Less.Options);\n\n    return {\n      contents: result.css,\n      loader: 'css',\n    };\n  } catch (error) {\n    if (isLessException(error)) {\n      return {\n        errors: [\n          {\n            text: error.message,\n            location: {\n              file: error.filename,\n              line: error.line,\n              column: error.column,\n              // Middle element represents the line containing the error\n              lineText: error.extract && error.extract[Math.trunc(error.extract.length / 2)],\n            },\n          },\n        ],\n        loader: 'css',\n      };\n    }\n\n    throw error;\n  }\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/sass-plugin.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/sass-plugin.d.ts new file mode 100644 index 00000000..e6b3e187 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/sass-plugin.d.ts @@ -0,0 +1,16 @@ +/** + * @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 type { Plugin } from 'esbuild'; +import type { LoadResultCache } from '../load-result-cache'; +export interface SassPluginOptions { + sourcemap: boolean; + loadPaths?: string[]; + inlineComponentData?: Record; +} +export declare function shutdownSassWorkerPool(): void; +export declare function createSassPlugin(options: SassPluginOptions, cache?: LoadResultCache): Plugin; diff --git a/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/sass-plugin.js b/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/sass-plugin.js new file mode 100644 index 00000000..dd99ead3 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/stylesheets/sass-plugin.js @@ -0,0 +1,201 @@ +"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; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createSassPlugin = exports.shutdownSassWorkerPool = void 0; +const node_assert_1 = __importDefault(require("node:assert")); +const promises_1 = require("node:fs/promises"); +const node_path_1 = require("node:path"); +const node_url_1 = require("node:url"); +let sassWorkerPool; +function isSassException(error) { + return !!error && typeof error === 'object' && 'sassMessage' in error; +} +function shutdownSassWorkerPool() { + sassWorkerPool?.close(); + sassWorkerPool = undefined; +} +exports.shutdownSassWorkerPool = shutdownSassWorkerPool; +function createSassPlugin(options, cache) { + return { + name: 'angular-sass', + setup(build) { + const resolveUrl = async (url, previousResolvedModules) => { + let result = await build.resolve(url, { + kind: 'import-rule', + // This should ideally be the directory of the importer file from Sass + // but that is not currently available from the Sass importer API. + resolveDir: build.initialOptions.absWorkingDir, + }); + // Workaround to support Yarn PnP without access to the importer file from Sass + if (!result.path && previousResolvedModules?.size) { + for (const previous of previousResolvedModules) { + result = await build.resolve(url, { + kind: 'import-rule', + resolveDir: previous, + }); + if (result.path) { + break; + } + } + } + return result; + }; + build.onLoad({ filter: /^s[ac]ss;/, namespace: 'angular:styles/component' }, async (args) => { + const data = options.inlineComponentData?.[args.path]; + (0, node_assert_1.default)(typeof data === 'string', `component style name should always be found [${args.path}]`); + let result = cache?.get(data); + if (result === undefined) { + const [language, , filePath] = args.path.split(';', 3); + const syntax = language === 'sass' ? 'indented' : 'scss'; + result = await compileString(data, filePath, syntax, options, resolveUrl); + if (result.errors === undefined) { + // Cache the result if there were no errors + await cache?.put(data, result); + } + } + return result; + }); + build.onLoad({ filter: /\.s[ac]ss$/ }, async (args) => { + let result = cache?.get(args.path); + if (result === undefined) { + const data = await (0, promises_1.readFile)(args.path, 'utf-8'); + const syntax = (0, node_path_1.extname)(args.path).toLowerCase() === '.sass' ? 'indented' : 'scss'; + result = await compileString(data, args.path, syntax, options, resolveUrl); + if (result.errors === undefined) { + // Cache the result if there were no errors + await cache?.put(args.path, result); + } + } + return result; + }); + }, + }; +} +exports.createSassPlugin = createSassPlugin; +async function compileString(data, filePath, syntax, options, resolveUrl) { + // Lazily load Sass when a Sass file is found + if (sassWorkerPool === undefined) { + const sassService = await Promise.resolve().then(() => __importStar(require('../../../sass/sass-service'))); + sassWorkerPool = new sassService.SassWorkerImplementation(true); + } + const warnings = []; + try { + const { css, sourceMap, loadedUrls } = await sassWorkerPool.compileStringAsync(data, { + url: (0, node_url_1.pathToFileURL)(filePath), + style: 'expanded', + syntax, + loadPaths: options.loadPaths, + sourceMap: options.sourcemap, + sourceMapIncludeSources: options.sourcemap, + quietDeps: true, + importers: [ + { + findFileUrl: async (url, { previousResolvedModules }) => { + let result = await resolveUrl(url); + if (result.path) { + return (0, node_url_1.pathToFileURL)(result.path); + } + // Check for package deep imports + const parts = url.split('/'); + const hasScope = parts.length >= 2 && parts[0].startsWith('@'); + const [nameOrScope, nameOrFirstPath, ...pathPart] = parts; + const packageName = hasScope ? `${nameOrScope}/${nameOrFirstPath}` : nameOrScope; + let packageResult = await resolveUrl(packageName + '/package.json'); + if (packageResult.path) { + return (0, node_url_1.pathToFileURL)((0, node_path_1.join)((0, node_path_1.dirname)(packageResult.path), !hasScope && nameOrFirstPath ? nameOrFirstPath : '', ...pathPart)); + } + // Check with Yarn PnP workaround using previous resolved modules. + // This is done last to avoid a performance penalty for common cases. + result = await resolveUrl(url, previousResolvedModules); + if (result.path) { + return (0, node_url_1.pathToFileURL)(result.path); + } + packageResult = await resolveUrl(packageName + '/package.json', previousResolvedModules); + if (packageResult.path) { + return (0, node_url_1.pathToFileURL)((0, node_path_1.join)((0, node_path_1.dirname)(packageResult.path), !hasScope && nameOrFirstPath ? nameOrFirstPath : '', ...pathPart)); + } + // Not found + return null; + }, + }, + ], + logger: { + warn: (text, { deprecation, span }) => { + warnings.push({ + text: deprecation ? 'Deprecation' : text, + location: span && { + file: span.url && (0, node_url_1.fileURLToPath)(span.url), + lineText: span.context, + // Sass line numbers are 0-based while esbuild's are 1-based + line: span.start.line + 1, + column: span.start.column, + }, + notes: deprecation ? [{ text }] : undefined, + }); + }, + }, + }); + return { + loader: 'css', + contents: sourceMap ? `${css}\n${sourceMapToUrlComment(sourceMap, (0, node_path_1.dirname)(filePath))}` : css, + watchFiles: loadedUrls.map((url) => (0, node_url_1.fileURLToPath)(url)), + warnings, + }; + } + catch (error) { + if (isSassException(error)) { + const file = error.span.url ? (0, node_url_1.fileURLToPath)(error.span.url) : undefined; + return { + loader: 'css', + errors: [ + { + text: error.message, + }, + ], + warnings, + watchFiles: file ? [file] : undefined, + }; + } + throw error; + } +} +function sourceMapToUrlComment(sourceMap, root) { + // Remove `file` protocol from all sourcemap sources and adjust to be relative to the input file. + // This allows esbuild to correctly process the paths. + sourceMap.sources = sourceMap.sources.map((source) => (0, node_path_1.relative)(root, (0, node_url_1.fileURLToPath)(source))); + const urlSourceMap = Buffer.from(JSON.stringify(sourceMap), 'utf-8').toString('base64'); + return `/*# sourceMappingURL=data:application/json;charset=utf-8;base64,${urlSourceMap} */`; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sass-plugin.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/stylesheets/sass-plugin.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 type { OnLoadResult, PartialMessage, Plugin, PluginBuild, ResolveResult } from 'esbuild';\nimport assert from 'node:assert';\nimport { readFile } from 'node:fs/promises';\nimport { dirname, extname, join, relative } from 'node:path';\nimport { fileURLToPath, pathToFileURL } from 'node:url';\nimport type { CompileResult, Exception, Syntax } from 'sass';\nimport type {\n  FileImporterWithRequestContextOptions,\n  SassWorkerImplementation,\n} from '../../../sass/sass-service';\nimport type { LoadResultCache } from '../load-result-cache';\n\nexport interface SassPluginOptions {\n  sourcemap: boolean;\n  loadPaths?: string[];\n  inlineComponentData?: Record<string, string>;\n}\n\nlet sassWorkerPool: SassWorkerImplementation | undefined;\n\nfunction isSassException(error: unknown): error is Exception {\n  return !!error && typeof error === 'object' && 'sassMessage' in error;\n}\n\nexport function shutdownSassWorkerPool(): void {\n  sassWorkerPool?.close();\n  sassWorkerPool = undefined;\n}\n\nexport function createSassPlugin(options: SassPluginOptions, cache?: LoadResultCache): Plugin {\n  return {\n    name: 'angular-sass',\n    setup(build: PluginBuild): void {\n      const resolveUrl = async (url: string, previousResolvedModules?: Set<string>) => {\n        let result = await build.resolve(url, {\n          kind: 'import-rule',\n          // This should ideally be the directory of the importer file from Sass\n          // but that is not currently available from the Sass importer API.\n          resolveDir: build.initialOptions.absWorkingDir,\n        });\n\n        // Workaround to support Yarn PnP without access to the importer file from Sass\n        if (!result.path && previousResolvedModules?.size) {\n          for (const previous of previousResolvedModules) {\n            result = await build.resolve(url, {\n              kind: 'import-rule',\n              resolveDir: previous,\n            });\n            if (result.path) {\n              break;\n            }\n          }\n        }\n\n        return result;\n      };\n\n      build.onLoad({ filter: /^s[ac]ss;/, namespace: 'angular:styles/component' }, async (args) => {\n        const data = options.inlineComponentData?.[args.path];\n        assert(\n          typeof data === 'string',\n          `component style name should always be found [${args.path}]`,\n        );\n\n        let result = cache?.get(data);\n        if (result === undefined) {\n          const [language, , filePath] = args.path.split(';', 3);\n          const syntax = language === 'sass' ? 'indented' : 'scss';\n\n          result = await compileString(data, filePath, syntax, options, resolveUrl);\n          if (result.errors === undefined) {\n            // Cache the result if there were no errors\n            await cache?.put(data, result);\n          }\n        }\n\n        return result;\n      });\n\n      build.onLoad({ filter: /\\.s[ac]ss$/ }, async (args) => {\n        let result = cache?.get(args.path);\n        if (result === undefined) {\n          const data = await readFile(args.path, 'utf-8');\n          const syntax = extname(args.path).toLowerCase() === '.sass' ? 'indented' : 'scss';\n\n          result = await compileString(data, args.path, syntax, options, resolveUrl);\n          if (result.errors === undefined) {\n            // Cache the result if there were no errors\n            await cache?.put(args.path, result);\n          }\n        }\n\n        return result;\n      });\n    },\n  };\n}\n\nasync function compileString(\n  data: string,\n  filePath: string,\n  syntax: Syntax,\n  options: SassPluginOptions,\n  resolveUrl: (url: string, previousResolvedModules?: Set<string>) => Promise<ResolveResult>,\n): Promise<OnLoadResult> {\n  // Lazily load Sass when a Sass file is found\n  if (sassWorkerPool === undefined) {\n    const sassService = await import('../../../sass/sass-service');\n    sassWorkerPool = new sassService.SassWorkerImplementation(true);\n  }\n\n  const warnings: PartialMessage[] = [];\n  try {\n    const { css, sourceMap, loadedUrls } = await sassWorkerPool.compileStringAsync(data, {\n      url: pathToFileURL(filePath),\n      style: 'expanded',\n      syntax,\n      loadPaths: options.loadPaths,\n      sourceMap: options.sourcemap,\n      sourceMapIncludeSources: options.sourcemap,\n      quietDeps: true,\n      importers: [\n        {\n          findFileUrl: async (\n            url,\n            { previousResolvedModules }: FileImporterWithRequestContextOptions,\n          ): Promise<URL | null> => {\n            let result = await resolveUrl(url);\n            if (result.path) {\n              return pathToFileURL(result.path);\n            }\n\n            // Check for package deep imports\n            const parts = url.split('/');\n            const hasScope = parts.length >= 2 && parts[0].startsWith('@');\n            const [nameOrScope, nameOrFirstPath, ...pathPart] = parts;\n            const packageName = hasScope ? `${nameOrScope}/${nameOrFirstPath}` : nameOrScope;\n\n            let packageResult = await resolveUrl(packageName + '/package.json');\n\n            if (packageResult.path) {\n              return pathToFileURL(\n                join(\n                  dirname(packageResult.path),\n                  !hasScope && nameOrFirstPath ? nameOrFirstPath : '',\n                  ...pathPart,\n                ),\n              );\n            }\n\n            // Check with Yarn PnP workaround using previous resolved modules.\n            // This is done last to avoid a performance penalty for common cases.\n\n            result = await resolveUrl(url, previousResolvedModules);\n            if (result.path) {\n              return pathToFileURL(result.path);\n            }\n\n            packageResult = await resolveUrl(\n              packageName + '/package.json',\n              previousResolvedModules,\n            );\n\n            if (packageResult.path) {\n              return pathToFileURL(\n                join(\n                  dirname(packageResult.path),\n                  !hasScope && nameOrFirstPath ? nameOrFirstPath : '',\n                  ...pathPart,\n                ),\n              );\n            }\n\n            // Not found\n            return null;\n          },\n        },\n      ],\n      logger: {\n        warn: (text, { deprecation, span }) => {\n          warnings.push({\n            text: deprecation ? 'Deprecation' : text,\n            location: span && {\n              file: span.url && fileURLToPath(span.url),\n              lineText: span.context,\n              // Sass line numbers are 0-based while esbuild's are 1-based\n              line: span.start.line + 1,\n              column: span.start.column,\n            },\n            notes: deprecation ? [{ text }] : undefined,\n          });\n        },\n      },\n    });\n\n    return {\n      loader: 'css',\n      contents: sourceMap ? `${css}\\n${sourceMapToUrlComment(sourceMap, dirname(filePath))}` : css,\n      watchFiles: loadedUrls.map((url) => fileURLToPath(url)),\n      warnings,\n    };\n  } catch (error) {\n    if (isSassException(error)) {\n      const file = error.span.url ? fileURLToPath(error.span.url) : undefined;\n\n      return {\n        loader: 'css',\n        errors: [\n          {\n            text: error.message,\n          },\n        ],\n        warnings,\n        watchFiles: file ? [file] : undefined,\n      };\n    }\n\n    throw error;\n  }\n}\n\nfunction sourceMapToUrlComment(\n  sourceMap: Exclude<CompileResult['sourceMap'], undefined>,\n  root: string,\n): string {\n  // Remove `file` protocol from all sourcemap sources and adjust to be relative to the input file.\n  // This allows esbuild to correctly process the paths.\n  sourceMap.sources = sourceMap.sources.map((source) => relative(root, fileURLToPath(source)));\n\n  const urlSourceMap = Buffer.from(JSON.stringify(sourceMap), 'utf-8').toString('base64');\n\n  return `/*# sourceMappingURL=data:application/json;charset=utf-8;base64,${urlSourceMap} */`;\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-esbuild/watcher.d.ts b/artifacts/build-angular/src/builders/browser-esbuild/watcher.d.ts new file mode 100644 index 00000000..9f05840e --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/watcher.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 + */ +export declare class ChangedFiles { + readonly added: Set; + readonly modified: Set; + readonly removed: Set; + toDebugString(): string; +} +export interface BuildWatcher extends AsyncIterableIterator { + add(paths: string | string[]): void; + remove(paths: string | string[]): void; + close(): Promise; +} +export declare function createWatcher(options?: { + polling?: boolean; + interval?: number; + ignored?: string[]; +}): BuildWatcher; diff --git a/artifacts/build-angular/src/builders/browser-esbuild/watcher.js b/artifacts/build-angular/src/builders/browser-esbuild/watcher.js new file mode 100644 index 00000000..81690480 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-esbuild/watcher.js @@ -0,0 +1,105 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createWatcher = exports.ChangedFiles = void 0; +const chokidar_1 = require("chokidar"); +class ChangedFiles { + constructor() { + this.added = new Set(); + this.modified = new Set(); + this.removed = new Set(); + } + toDebugString() { + const content = { + added: Array.from(this.added), + modified: Array.from(this.modified), + removed: Array.from(this.removed), + }; + return JSON.stringify(content, null, 2); + } +} +exports.ChangedFiles = ChangedFiles; +function createWatcher(options) { + const watcher = new chokidar_1.FSWatcher({ + ...options, + disableGlobbing: true, + ignoreInitial: true, + }); + const nextQueue = []; + let currentChanges; + let nextWaitTimeout; + watcher.on('all', (event, path) => { + switch (event) { + case 'add': + currentChanges ?? (currentChanges = new ChangedFiles()); + currentChanges.added.add(path); + break; + case 'change': + currentChanges ?? (currentChanges = new ChangedFiles()); + currentChanges.modified.add(path); + break; + case 'unlink': + currentChanges ?? (currentChanges = new ChangedFiles()); + currentChanges.removed.add(path); + break; + default: + return; + } + // Wait 250ms from next change to better capture groups of file save operations. + if (!nextWaitTimeout) { + nextWaitTimeout = setTimeout(() => { + nextWaitTimeout = undefined; + const next = nextQueue.shift(); + if (next) { + const value = currentChanges; + currentChanges = undefined; + next(value); + } + }, 250); + nextWaitTimeout?.unref(); + } + }); + return { + [Symbol.asyncIterator]() { + return this; + }, + async next() { + if (currentChanges && nextQueue.length === 0) { + const result = { value: currentChanges }; + currentChanges = undefined; + return result; + } + return new Promise((resolve) => { + nextQueue.push((value) => resolve(value ? { value } : { done: true, value })); + }); + }, + add(paths) { + watcher.add(paths); + }, + remove(paths) { + watcher.unwatch(paths); + }, + async close() { + try { + await watcher.close(); + if (nextWaitTimeout) { + clearTimeout(nextWaitTimeout); + } + } + finally { + let next; + while ((next = nextQueue.shift()) !== undefined) { + next(); + } + } + }, + }; +} +exports.createWatcher = createWatcher; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-rspack/index.d.ts b/artifacts/build-angular/src/builders/browser-rspack/index.d.ts new file mode 100644 index 00000000..5837b9b6 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-rspack/index.d.ts @@ -0,0 +1,42 @@ +/** + * @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 { WebpackLoggingCallback } from '@angular-devkit/build-webpack'; +import { Observable } from 'rxjs'; +import webpack from 'webpack'; +import { ExecutionTransformer } from '../../transforms'; +import { IndexHtmlTransform } from '../../utils/index-file/index-html-generator'; +import { BuildEventStats } from '../../webpack/utils/stats'; +import { Schema as BrowserBuilderSchema } from './schema'; +/** + * @experimental Direct usage of this type is considered experimental. + */ +export type BrowserBuilderOutput = BuilderOutput & { + stats: BuildEventStats; + baseOutputPath: string; + outputs: { + locale?: string; + path: string; + baseHref?: string; + }[]; +}; +/** + * Maximum time in milliseconds for single build/rebuild + * This accounts for CI variability. + */ +export declare const BUILD_TIMEOUT = 30000; +/** + * @experimental Direct usage of this function is considered experimental. + */ +export declare function buildWebpackBrowser(options: BrowserBuilderSchema, context: BuilderContext, transforms?: { + webpackConfiguration?: ExecutionTransformer; + logging?: WebpackLoggingCallback; + indexHtml?: IndexHtmlTransform; +}): Observable; +declare const _default: import("../../../../architect/src/internal").Builder; +export default _default; diff --git a/artifacts/build-angular/src/builders/browser-rspack/index.js b/artifacts/build-angular/src/builders/browser-rspack/index.js new file mode 100644 index 00000000..b1da039f --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-rspack/index.js @@ -0,0 +1,332 @@ +"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.buildWebpackBrowser = exports.BUILD_TIMEOUT = void 0; +const architect_1 = require("@angular-devkit/architect"); +const build_webpack_1 = require("@angular-devkit/build-webpack"); +const fs = __importStar(require("fs")); +const path = __importStar(require("path")); +const rxjs_1 = require("rxjs"); +const utils_1 = require("../../utils"); +const bundle_calculator_1 = require("../../utils/bundle-calculator"); +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 index_html_generator_1 = require("../../utils/index-file/index-html-generator"); +const normalize_cache_1 = require("../../utils/normalize-cache"); +const output_paths_1 = require("../../utils/output-paths"); +const package_chunk_sort_1 = require("../../utils/package-chunk-sort"); +const purge_cache_1 = require("../../utils/purge-cache"); +const service_worker_1 = require("../../utils/service-worker"); +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"); +const async_chunks_1 = require("../../webpack/utils/async-chunks"); +const helpers_1 = require("../../webpack/utils/helpers"); +const stats_1 = require("../../webpack/utils/stats"); +const webpack_factory_adapter_1 = require("./webpack-factory-adapter"); +/** + * Maximum time in milliseconds for single build/rebuild + * This accounts for CI variability. + */ +exports.BUILD_TIMEOUT = 30000; +async function initialize(options, context, webpackConfigurationTransform) { + const originalOutputPath = options.outputPath; + // 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, context, (wco) => [ + (0, configs_1.getCommonConfig)(Object.assign(wco, { isRsPack: true })), + (0, configs_1.getStylesConfig)(wco), + ]); + let transformedConfig; + if (webpackConfigurationTransform) { + transformedConfig = await webpackConfigurationTransform(config); + } + if (options.deleteOutputPath) { + (0, utils_1.deleteOutputDir)(context.workspaceRoot, originalOutputPath); + } + return { config: transformedConfig || config, projectRoot, projectSourceRoot, i18n }; +} +/** + * @experimental Direct usage of this function is considered experimental. + */ +// eslint-disable-next-line max-lines-per-function +function buildWebpackBrowser(options, context, transforms = {}) { + const projectName = context.target?.project; + if (!projectName) { + throw new Error('The builder requires a target.'); + } + const baseOutputPath = path.resolve(context.workspaceRoot, options.outputPath); + let outputPaths; + // Check Angular version. + (0, version_1.assertCompatibleAngularVersion)(context.workspaceRoot); + return (0, rxjs_1.from)(context.getProjectMetadata(projectName)).pipe((0, rxjs_1.switchMap)(async (projectMetadata) => { + var _a; + // Purge old build disk cache. + await (0, purge_cache_1.purgeStaleBuildCache)(context); + // Initialize builder + const initialization = await initialize(options, context, transforms.webpackConfiguration); + // Add index file to watched files. + if (options.watch) { + const indexInputFile = path.join(context.workspaceRoot, (0, webpack_browser_config_1.getIndexInputFile)(options.index)); + (_a = initialization.config).plugins ?? (_a.plugins = []); + initialization.config.plugins.push({ + apply: (compiler) => { + compiler.hooks.thisCompilation.tap('build-angular', (compilation) => { + compilation.fileDependencies.add(indexInputFile); + }); + }, + }); + } + return { + ...initialization, + cacheOptions: (0, normalize_cache_1.normalizeCacheOptions)(projectMetadata, context.workspaceRoot), + }; + }), (0, rxjs_1.switchMap)( + // eslint-disable-next-line max-lines-per-function + ({ config, projectRoot, projectSourceRoot, i18n, cacheOptions }) => { + const normalizedOptimization = (0, utils_1.normalizeOptimization)(options.optimization); + return (0, build_webpack_1.runWebpack)(config, context, { + // webpackFactory: require('webpack') as typeof webpack, + webpackFactory: webpack_factory_adapter_1.webpackFactory, + logging: transforms.logging || + ((stats, config) => { + if (options.verbose) { + context.logger.info(stats.toString(config.stats)); + } + }), + }).pipe((0, rxjs_1.concatMap)( + // eslint-disable-next-line max-lines-per-function + async (buildEvent) => { + const spinner = new spinner_1.Spinner(); + spinner.enabled = options.progress !== false; + const { success, emittedFiles = [], outputPath: webpackOutputPath } = buildEvent; + const webpackRawStats = buildEvent.webpackStats; + if (!webpackRawStats) { + throw new Error('Webpack stats build result is required.'); + } + // Fix incorrectly set `initial` value on chunks. + const extraEntryPoints = [ + ...(0, helpers_1.normalizeExtraEntryPoints)(options.styles || [], 'styles'), + ...(0, helpers_1.normalizeExtraEntryPoints)(options.scripts || [], 'scripts'), + ]; + const webpackStats = { + ...webpackRawStats, + chunks: (0, async_chunks_1.markAsyncChunksNonInitial)(webpackRawStats, extraEntryPoints), + }; + if (!success) { + // If using bundle downleveling then there is only one build + // If it fails show any diagnostic messages and bail + if ((0, stats_1.statsHasWarnings)(webpackStats)) { + context.logger.warn((0, stats_1.statsWarningsToString)(webpackStats, { colors: true })); + } + if ((0, stats_1.statsHasErrors)(webpackStats)) { + context.logger.error((0, stats_1.statsErrorsToString)(webpackStats, { colors: true })); + } + return { + webpackStats: webpackRawStats, + output: { success: false }, + }; + } + else { + outputPaths = (0, output_paths_1.ensureOutputPaths)(baseOutputPath, i18n); + const scriptsEntryPointName = (0, helpers_1.normalizeExtraEntryPoints)(options.scripts || [], 'scripts').map((x) => x.bundleName); + if (i18n.shouldInline) { + const success = await (0, i18n_inlining_1.i18nInlineEmittedFiles)(context, emittedFiles, i18n, baseOutputPath, Array.from(outputPaths.values()), scriptsEntryPointName, webpackOutputPath, options.i18nMissingTranslation); + if (!success) { + return { + webpackStats: webpackRawStats, + output: { success: false }, + }; + } + } + // Check for budget errors and display them to the user. + const budgets = options.budgets; + let budgetFailures; + if (budgets?.length) { + budgetFailures = [...(0, bundle_calculator_1.checkBudgets)(budgets, webpackStats)]; + for (const { severity, message } of budgetFailures) { + switch (severity) { + case bundle_calculator_1.ThresholdSeverity.Warning: + webpackStats.warnings?.push({ message }); + break; + case bundle_calculator_1.ThresholdSeverity.Error: + webpackStats.errors?.push({ message }); + break; + default: + assertNever(severity); + } + } + } + const buildSuccess = success && !(0, stats_1.statsHasErrors)(webpackStats); + if (buildSuccess) { + // Copy assets + if (!options.watch && options.assets?.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, + }, + webpackStats: webpackRawStats, + }; + } + } + if (options.index) { + spinner.start('Generating index html...'); + const entrypoints = (0, package_chunk_sort_1.generateEntryPoints)({ + scripts: options.scripts ?? [], + styles: options.styles ?? [], + }); + const indexHtmlGenerator = new index_html_generator_1.IndexHtmlGenerator({ + cache: cacheOptions, + indexPath: path.join(context.workspaceRoot, (0, webpack_browser_config_1.getIndexInputFile)(options.index)), + entrypoints, + deployUrl: options.deployUrl, + sri: options.subresourceIntegrity, + optimization: normalizedOptimization, + crossOrigin: options.crossOrigin, + postTransform: transforms.indexHtml, + }); + let hasErrors = false; + for (const [locale, outputPath] of outputPaths.entries()) { + try { + const { content, warnings, errors } = await indexHtmlGenerator.process({ + baseHref: getLocaleBaseHref(i18n, locale) ?? options.baseHref, + // i18nLocale is used when Ivy is disabled + lang: locale || undefined, + outputPath, + files: mapEmittedFilesToFileInfo(emittedFiles), + }); + if (warnings.length || errors.length) { + spinner.stop(); + warnings.forEach((m) => context.logger.warn(m)); + errors.forEach((m) => { + context.logger.error(m); + hasErrors = true; + }); + spinner.start(); + } + const indexOutput = path.join(outputPath, (0, webpack_browser_config_1.getIndexOutputFile)(options.index)); + await fs.promises.mkdir(path.dirname(indexOutput), { recursive: true }); + await fs.promises.writeFile(indexOutput, content); + } + catch (error) { + spinner.fail('Index html generation failed.'); + (0, error_1.assertIsError)(error); + return { + webpackStats: webpackRawStats, + output: { success: false, error: error.message }, + }; + } + } + if (hasErrors) { + spinner.fail('Index html generation failed.'); + return { + webpackStats: webpackRawStats, + output: { success: false }, + }; + } + else { + spinner.succeed('Index html generation complete.'); + } + } + if (options.serviceWorker) { + spinner.start('Generating service worker...'); + for (const [locale, outputPath] of outputPaths.entries()) { + try { + await (0, service_worker_1.augmentAppWithServiceWorker)(projectRoot, context.workspaceRoot, outputPath, getLocaleBaseHref(i18n, locale) ?? options.baseHref ?? '/', options.ngswConfigPath); + } + catch (error) { + spinner.fail('Service worker generation failed.'); + (0, error_1.assertIsError)(error); + return { + webpackStats: webpackRawStats, + output: { success: false, error: error.message }, + }; + } + } + spinner.succeed('Service worker generation complete.'); + } + } + (0, stats_1.webpackStatsLogger)(context.logger, webpackStats, config, budgetFailures); + return { + webpackStats: webpackRawStats, + output: { success: buildSuccess }, + }; + } + }), (0, rxjs_1.map)(({ output: event, webpackStats }) => ({ + ...event, + stats: (0, stats_1.generateBuildEventStats)(webpackStats, options), + baseOutputPath, + outputs: (outputPaths && + [...outputPaths.entries()].map(([locale, path]) => ({ + locale, + path, + baseHref: getLocaleBaseHref(i18n, locale) ?? options.baseHref, + }))) || { + path: baseOutputPath, + baseHref: options.baseHref, + }, + }))); + })); + function getLocaleBaseHref(i18n, locale) { + if (i18n.locales[locale] && i18n.locales[locale]?.baseHref !== '') { + return (0, utils_1.urlJoin)(options.baseHref || '', i18n.locales[locale].baseHref ?? `/${locale}/`); + } + return undefined; + } +} +exports.buildWebpackBrowser = buildWebpackBrowser; +function assertNever(input) { + throw new Error(`Unexpected call to assertNever() with input: ${JSON.stringify(input, null /* replacer */, 4 /* tabSize */)}`); +} +function mapEmittedFilesToFileInfo(files = []) { + const filteredFiles = []; + for (const { file, name, extension, initial } of files) { + if (name && initial) { + filteredFiles.push({ file, extension, name }); + } + } + return filteredFiles; +} +exports.default = (0, architect_1.createBuilder)(buildWebpackBrowser); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-rspack/index.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,yDAAyF;AACzF,iEAAiG;AACjG,uCAAyB;AACzB,2CAA6B;AAC7B,+BAAmE;AAGnE,uCAKqB;AACrB,qEAIuC;AACvC,6CAA2C;AAC3C,yDAAqD;AACrD,6CAAkD;AAClD,6DAAmE;AAGnE,sFAGqD;AACrD,iEAAoE;AACpE,2DAA6D;AAC7D,uEAAqE;AACrE,yDAA+D;AAC/D,+DAAyE;AACzE,iDAA8C;AAC9C,iDAAqE;AACrE,+EAI4C;AAC5C,mDAAyE;AACzE,mEAA6E;AAC7E,yDAAwE;AACxE,qDAQmC;AAGnC,uEAA2D;AAe3D;;;GAGG;AACU,QAAA,aAAa,GAAG,KAAM,CAAC;AAEpC,KAAK,UAAU,UAAU,CACvB,OAA6B,EAC7B,OAAuB,EACvB,6BAA2E;IAO3E,MAAM,kBAAkB,GAAG,OAAO,CAAC,UAAU,CAAC;IAE9C,oEAAoE;IACpE,MAAM,eAAe,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;IAE7E,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,iBAAiB,EAAE,IAAI,EAAE,GACpD,MAAM,IAAA,oEAA2C,EAAC,eAAe,EAAE,OAAO,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC;QACnF,IAAA,yBAAe,EAAC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;QACvD,IAAA,yBAAe,EAAC,GAAG,CAAC;KACrB,CAAC,CAAC;IAEL,IAAI,iBAAiB,CAAC;IACtB,IAAI,6BAA6B,EAAE;QACjC,iBAAiB,GAAG,MAAM,6BAA6B,CAAC,MAAM,CAAC,CAAC;KACjE;IAED,IAAI,OAAO,CAAC,gBAAgB,EAAE;QAC5B,IAAA,uBAAe,EAAC,OAAO,CAAC,aAAa,EAAE,kBAAkB,CAAC,CAAC;KAC5D;IAED,OAAO,EAAE,MAAM,EAAE,iBAAiB,IAAI,MAAM,EAAE,WAAW,EAAE,iBAAiB,EAAE,IAAI,EAAE,CAAC;AACvF,CAAC;AAED;;GAEG;AACH,kDAAkD;AAClD,SAAgB,mBAAmB,CACjC,OAA6B,EAC7B,OAAuB,EACvB,aAII,EAAE;IAEN,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC;IAC5C,IAAI,CAAC,WAAW,EAAE;QAChB,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;KACnD;IAED,MAAM,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,aAAa,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IAC/E,IAAI,WAA4C,CAAC;IAEjD,yBAAyB;IACzB,IAAA,wCAA8B,EAAC,OAAO,CAAC,aAAa,CAAC,CAAC;IAEtD,OAAO,IAAA,WAAI,EAAC,OAAO,CAAC,kBAAkB,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CACvD,IAAA,gBAAS,EAAC,KAAK,EAAE,eAAe,EAAE,EAAE;;QAClC,8BAA8B;QAC9B,MAAM,IAAA,kCAAoB,EAAC,OAAO,CAAC,CAAC;QAEpC,qBAAqB;QACrB,MAAM,cAAc,GAAG,MAAM,UAAU,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,CAAC,oBAAoB,CAAC,CAAC;QAE3F,mCAAmC;QACnC,IAAI,OAAO,CAAC,KAAK,EAAE;YACjB,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,IAAA,0CAAiB,EAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;YAC1F,MAAA,cAAc,CAAC,MAAM,EAAC,OAAO,QAAP,OAAO,GAAK,EAAE,EAAC;YACrC,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC;gBACjC,KAAK,EAAE,CAAC,QAA0B,EAAE,EAAE;oBACpC,QAAQ,CAAC,KAAK,CAAC,eAAe,CAAC,GAAG,CAAC,eAAe,EAAE,CAAC,WAAW,EAAE,EAAE;wBAClE,WAAW,CAAC,gBAAgB,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;oBACnD,CAAC,CAAC,CAAC;gBACL,CAAC;aACF,CAAC,CAAC;SACJ;QAED,OAAO;YACL,GAAG,cAAc;YACjB,YAAY,EAAE,IAAA,uCAAqB,EAAC,eAAe,EAAE,OAAO,CAAC,aAAa,CAAC;SAC5E,CAAC;IACJ,CAAC,CAAC,EACF,IAAA,gBAAS;IACP,kDAAkD;IAClD,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,iBAAiB,EAAE,IAAI,EAAE,YAAY,EAAE,EAAE,EAAE;QACjE,MAAM,sBAAsB,GAAG,IAAA,6BAAqB,EAAC,OAAO,CAAC,YAAY,CAAC,CAAC;QAE3E,OAAO,IAAA,0BAAU,EAAC,MAAM,EAAE,OAAO,EAAE;YACjC,wDAAwD;YACxD,cAAc,EAAE,wCAA2C;YAC3D,OAAO,EACL,UAAU,CAAC,OAAO;gBAClB,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE;oBACjB,IAAI,OAAO,CAAC,OAAO,EAAE;wBACnB,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;qBACnD;gBACH,CAAC,CAAC;SACL,CAAC,CAAC,IAAI,CACL,IAAA,gBAAS;QACP,kDAAkD;QAClD,KAAK,EACH,UAAU,EAC0D,EAAE;YACtE,MAAM,OAAO,GAAG,IAAI,iBAAO,EAAE,CAAC;YAC9B,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC,QAAQ,KAAK,KAAK,CAAC;YAE7C,MAAM,EAAE,OAAO,EAAE,YAAY,GAAG,EAAE,EAAE,UAAU,EAAE,iBAAiB,EAAE,GAAG,UAAU,CAAC;YACjF,MAAM,eAAe,GAAG,UAAU,CAAC,YAAY,CAAC;YAChD,IAAI,CAAC,eAAe,EAAE;gBACpB,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;aAC5D;YAED,iDAAiD;YACjD,MAAM,gBAAgB,GAAG;gBACvB,GAAG,IAAA,mCAAyB,EAAC,OAAO,CAAC,MAAM,IAAI,EAAE,EAAE,QAAQ,CAAC;gBAC5D,GAAG,IAAA,mCAAyB,EAAC,OAAO,CAAC,OAAO,IAAI,EAAE,EAAE,SAAS,CAAC;aAC/D,CAAC;YAEF,MAAM,YAAY,GAAG;gBACnB,GAAG,eAAe;gBAClB,MAAM,EAAE,IAAA,wCAAyB,EAAC,eAAe,EAAE,gBAAgB,CAAC;aACrE,CAAC;YAEF,IAAI,CAAC,OAAO,EAAE;gBACZ,4DAA4D;gBAC5D,oDAAoD;gBACpD,IAAI,IAAA,wBAAgB,EAAC,YAAY,CAAC,EAAE;oBAClC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,IAAA,6BAAqB,EAAC,YAAY,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;iBAC5E;gBACD,IAAI,IAAA,sBAAc,EAAC,YAAY,CAAC,EAAE;oBAChC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAA,2BAAmB,EAAC,YAAY,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;iBAC3E;gBAED,OAAO;oBACL,YAAY,EAAE,eAAe;oBAC7B,MAAM,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE;iBAC3B,CAAC;aACH;iBAAM;gBACL,WAAW,GAAG,IAAA,gCAAiB,EAAC,cAAc,EAAE,IAAI,CAAC,CAAC;gBAEtD,MAAM,qBAAqB,GAAG,IAAA,mCAAyB,EACrD,OAAO,CAAC,OAAO,IAAI,EAAE,EACrB,SAAS,CACV,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;gBAE3B,IAAI,IAAI,CAAC,YAAY,EAAE;oBACrB,MAAM,OAAO,GAAG,MAAM,IAAA,sCAAsB,EAC1C,OAAO,EACP,YAAY,EACZ,IAAI,EACJ,cAAc,EACd,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,CAAC,EAChC,qBAAqB,EACrB,iBAAiB,EACjB,OAAO,CAAC,sBAAsB,CAC/B,CAAC;oBACF,IAAI,CAAC,OAAO,EAAE;wBACZ,OAAO;4BACL,YAAY,EAAE,eAAe;4BAC7B,MAAM,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE;yBAC3B,CAAC;qBACH;iBACF;gBAED,wDAAwD;gBACxD,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;gBAChC,IAAI,cAAoD,CAAC;gBACzD,IAAI,OAAO,EAAE,MAAM,EAAE;oBACnB,cAAc,GAAG,CAAC,GAAG,IAAA,gCAAY,EAAC,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC;oBAC1D,KAAK,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,cAAc,EAAE;wBAClD,QAAQ,QAAQ,EAAE;4BAChB,KAAK,qCAAiB,CAAC,OAAO;gCAC5B,YAAY,CAAC,QAAQ,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC;gCACzC,MAAM;4BACR,KAAK,qCAAiB,CAAC,KAAK;gCAC1B,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC;gCACvC,MAAM;4BACR;gCACE,WAAW,CAAC,QAAQ,CAAC,CAAC;yBACzB;qBACF;iBACF;gBAED,MAAM,YAAY,GAAG,OAAO,IAAI,CAAC,IAAA,sBAAc,EAAC,YAAY,CAAC,CAAC;gBAC9D,IAAI,YAAY,EAAE;oBAChB,cAAc;oBACd,IAAI,CAAC,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE;wBAC5C,OAAO,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC;wBACnC,IAAI;4BACF,MAAM,IAAA,wBAAU,EACd,IAAA,8BAAsB,EACpB,OAAO,CAAC,MAAM,EACd,OAAO,CAAC,aAAa,EACrB,WAAW,EACX,iBAAiB,CAClB,EACD,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,CAAC,EAChC,OAAO,CAAC,aAAa,CACtB,CAAC;4BACF,OAAO,CAAC,OAAO,CAAC,0BAA0B,CAAC,CAAC;yBAC7C;wBAAC,OAAO,GAAG,EAAE;4BACZ,OAAO,CAAC,IAAI,CAAC,cAAM,CAAC,SAAS,CAAC,2BAA2B,CAAC,CAAC,CAAC;4BAC5D,IAAA,qBAAa,EAAC,GAAG,CAAC,CAAC;4BAEnB,OAAO;gCACL,MAAM,EAAE;oCACN,OAAO,EAAE,KAAK;oCACd,KAAK,EAAE,yBAAyB,GAAG,GAAG,CAAC,OAAO;iCAC/C;gCACD,YAAY,EAAE,eAAe;6BAC9B,CAAC;yBACH;qBACF;oBAED,IAAI,OAAO,CAAC,KAAK,EAAE;wBACjB,OAAO,CAAC,KAAK,CAAC,0BAA0B,CAAC,CAAC;wBAE1C,MAAM,WAAW,GAAG,IAAA,wCAAmB,EAAC;4BACtC,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,EAAE;4BAC9B,MAAM,EAAE,OAAO,CAAC,MAAM,IAAI,EAAE;yBAC7B,CAAC,CAAC;wBAEH,MAAM,kBAAkB,GAAG,IAAI,yCAAkB,CAAC;4BAChD,KAAK,EAAE,YAAY;4BACnB,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,IAAA,0CAAiB,EAAC,OAAO,CAAC,KAAK,CAAC,CAAC;4BAC7E,WAAW;4BACX,SAAS,EAAE,OAAO,CAAC,SAAS;4BAC5B,GAAG,EAAE,OAAO,CAAC,oBAAoB;4BACjC,YAAY,EAAE,sBAAsB;4BACpC,WAAW,EAAE,OAAO,CAAC,WAAW;4BAChC,aAAa,EAAE,UAAU,CAAC,SAAS;yBACpC,CAAC,CAAC;wBAEH,IAAI,SAAS,GAAG,KAAK,CAAC;wBACtB,KAAK,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,IAAI,WAAW,CAAC,OAAO,EAAE,EAAE;4BACxD,IAAI;gCACF,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,kBAAkB,CAAC,OAAO,CAAC;oCACrE,QAAQ,EAAE,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,OAAO,CAAC,QAAQ;oCAC7D,0CAA0C;oCAC1C,IAAI,EAAE,MAAM,IAAI,SAAS;oCACzB,UAAU;oCACV,KAAK,EAAE,yBAAyB,CAAC,YAAY,CAAC;iCAC/C,CAAC,CAAC;gCAEH,IAAI,QAAQ,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE;oCACpC,OAAO,CAAC,IAAI,EAAE,CAAC;oCACf,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;oCAChD,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;wCACnB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;wCACxB,SAAS,GAAG,IAAI,CAAC;oCACnB,CAAC,CAAC,CAAC;oCACH,OAAO,CAAC,KAAK,EAAE,CAAC;iCACjB;gCAED,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAC3B,UAAU,EACV,IAAA,2CAAkB,EAAC,OAAO,CAAC,KAAK,CAAC,CAClC,CAAC;gCACF,MAAM,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;gCACxE,MAAM,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;6BACnD;4BAAC,OAAO,KAAK,EAAE;gCACd,OAAO,CAAC,IAAI,CAAC,+BAA+B,CAAC,CAAC;gCAC9C,IAAA,qBAAa,EAAC,KAAK,CAAC,CAAC;gCAErB,OAAO;oCACL,YAAY,EAAE,eAAe;oCAC7B,MAAM,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE;iCACjD,CAAC;6BACH;yBACF;wBAED,IAAI,SAAS,EAAE;4BACb,OAAO,CAAC,IAAI,CAAC,+BAA+B,CAAC,CAAC;4BAE9C,OAAO;gCACL,YAAY,EAAE,eAAe;gCAC7B,MAAM,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE;6BAC3B,CAAC;yBACH;6BAAM;4BACL,OAAO,CAAC,OAAO,CAAC,iCAAiC,CAAC,CAAC;yBACpD;qBACF;oBAED,IAAI,OAAO,CAAC,aAAa,EAAE;wBACzB,OAAO,CAAC,KAAK,CAAC,8BAA8B,CAAC,CAAC;wBAC9C,KAAK,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,IAAI,WAAW,CAAC,OAAO,EAAE,EAAE;4BACxD,IAAI;gCACF,MAAM,IAAA,4CAA2B,EAC/B,WAAW,EACX,OAAO,CAAC,aAAa,EACrB,UAAU,EACV,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,OAAO,CAAC,QAAQ,IAAI,GAAG,EAC1D,OAAO,CAAC,cAAc,CACvB,CAAC;6BACH;4BAAC,OAAO,KAAK,EAAE;gCACd,OAAO,CAAC,IAAI,CAAC,mCAAmC,CAAC,CAAC;gCAClD,IAAA,qBAAa,EAAC,KAAK,CAAC,CAAC;gCAErB,OAAO;oCACL,YAAY,EAAE,eAAe;oCAC7B,MAAM,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE;iCACjD,CAAC;6BACH;yBACF;wBAED,OAAO,CAAC,OAAO,CAAC,qCAAqC,CAAC,CAAC;qBACxD;iBACF;gBAED,IAAA,0BAAkB,EAAC,OAAO,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,cAAc,CAAC,CAAC;gBAEzE,OAAO;oBACL,YAAY,EAAE,eAAe;oBAC7B,MAAM,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE;iBAClC,CAAC;aACH;QACH,CAAC,CACF,EACD,IAAA,UAAG,EACD,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,EAAE,EAAE,CAClC,CAAC;YACC,GAAG,KAAK;YACR,KAAK,EAAE,IAAA,+BAAuB,EAAC,YAAY,EAAE,OAAO,CAAC;YACrD,cAAc;YACd,OAAO,EAAE,CAAC,WAAW;gBACnB,CAAC,GAAG,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC;oBAClD,MAAM;oBACN,IAAI;oBACJ,QAAQ,EAAE,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,OAAO,CAAC,QAAQ;iBAC9D,CAAC,CAAC,CAAC,IAAI;gBACR,IAAI,EAAE,cAAc;gBACpB,QAAQ,EAAE,OAAO,CAAC,QAAQ;aAC3B;SACuB,CAAA,CAC7B,CACF,CAAC;IACJ,CAAC,CACF,CACF,CAAC;IAEF,SAAS,iBAAiB,CAAC,IAAiB,EAAE,MAAc;QAC1D,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,QAAQ,KAAK,EAAE,EAAE;YACjE,OAAO,IAAA,eAAO,EAAC,OAAO,CAAC,QAAQ,IAAI,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,QAAQ,IAAI,IAAI,MAAM,GAAG,CAAC,CAAC;SACxF;QAED,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC;AAvTD,kDAuTC;AAED,SAAS,WAAW,CAAC,KAAY;IAC/B,MAAM,IAAI,KAAK,CACb,gDAAgD,IAAI,CAAC,SAAS,CAC5D,KAAK,EACL,IAAI,CAAC,cAAc,EACnB,CAAC,CAAC,aAAa,CAChB,EAAE,CACJ,CAAC;AACJ,CAAC;AAED,SAAS,yBAAyB,CAAC,QAAwB,EAAE;IAC3D,MAAM,aAAa,GAAe,EAAE,CAAC;IACrC,KAAK,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,KAAK,EAAE;QACtD,IAAI,IAAI,IAAI,OAAO,EAAE;YACnB,aAAa,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;SAC/C;KACF;IAED,OAAO,aAAa,CAAC;AACvB,CAAC;AAED,kBAAe,IAAA,yBAAa,EAAuB,mBAAmB,CAAC,CAAC","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 { BuilderContext, BuilderOutput, createBuilder } from '@angular-devkit/architect';\nimport { EmittedFiles, WebpackLoggingCallback, runWebpack } from '@angular-devkit/build-webpack';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { Observable, concatMap, from, map, switchMap } from 'rxjs';\nimport webpack, { StatsCompilation } from 'webpack';\nimport { ExecutionTransformer } from '../../transforms';\nimport {\n  deleteOutputDir,\n  normalizeAssetPatterns,\n  normalizeOptimization,\n  urlJoin,\n} from '../../utils';\nimport {\n  BudgetCalculatorResult,\n  ThresholdSeverity,\n  checkBudgets,\n} from '../../utils/bundle-calculator';\nimport { colors } from '../../utils/color';\nimport { copyAssets } from '../../utils/copy-assets';\nimport { assertIsError } from '../../utils/error';\nimport { i18nInlineEmittedFiles } from '../../utils/i18n-inlining';\nimport { I18nOptions } from '../../utils/i18n-options';\nimport { FileInfo } from '../../utils/index-file/augment-index-html';\nimport {\n  IndexHtmlGenerator,\n  IndexHtmlTransform,\n} from '../../utils/index-file/index-html-generator';\nimport { normalizeCacheOptions } from '../../utils/normalize-cache';\nimport { ensureOutputPaths } from '../../utils/output-paths';\nimport { generateEntryPoints } from '../../utils/package-chunk-sort';\nimport { purgeStaleBuildCache } from '../../utils/purge-cache';\nimport { augmentAppWithServiceWorker } from '../../utils/service-worker';\nimport { Spinner } from '../../utils/spinner';\nimport { assertCompatibleAngularVersion } from '../../utils/version';\nimport {\n  generateI18nBrowserWebpackConfigFromContext,\n  getIndexInputFile,\n  getIndexOutputFile,\n} from '../../utils/webpack-browser-config';\nimport { getCommonConfig, getStylesConfig } from '../../webpack/configs';\nimport { markAsyncChunksNonInitial } from '../../webpack/utils/async-chunks';\nimport { normalizeExtraEntryPoints } from '../../webpack/utils/helpers';\nimport {\n  BuildEventStats,\n  generateBuildEventStats,\n  statsErrorsToString,\n  statsHasErrors,\n  statsHasWarnings,\n  statsWarningsToString,\n  webpackStatsLogger,\n} from '../../webpack/utils/stats';\nimport { Schema as BrowserBuilderSchema } from './schema';\n\nimport { webpackFactory } from './webpack-factory-adapter';\n\n/**\n * @experimental Direct usage of this type is considered experimental.\n */\nexport type BrowserBuilderOutput = BuilderOutput & {\n  stats: BuildEventStats;\n  baseOutputPath: string;\n  outputs: {\n    locale?: string;\n    path: string;\n    baseHref?: string;\n  }[];\n};\n\n/**\n * Maximum time in milliseconds for single build/rebuild\n * This accounts for CI variability.\n */\nexport const BUILD_TIMEOUT = 30_000;\n\nasync function initialize(\n  options: BrowserBuilderSchema,\n  context: BuilderContext,\n  webpackConfigurationTransform?: ExecutionTransformer<webpack.Configuration>,\n): Promise<{\n  config: webpack.Configuration;\n  projectRoot: string;\n  projectSourceRoot?: string;\n  i18n: I18nOptions;\n}> {\n  const originalOutputPath = options.outputPath;\n\n  // Assets are processed directly by the builder except when watching\n  const adjustedOptions = options.watch ? options : { ...options, assets: [] };\n\n  const { config, projectRoot, projectSourceRoot, i18n } =\n    await generateI18nBrowserWebpackConfigFromContext(adjustedOptions, context, (wco) => [\n      getCommonConfig(Object.assign(wco, { isRsPack: true })),\n      getStylesConfig(wco),\n    ]);\n\n  let transformedConfig;\n  if (webpackConfigurationTransform) {\n    transformedConfig = await webpackConfigurationTransform(config);\n  }\n\n  if (options.deleteOutputPath) {\n    deleteOutputDir(context.workspaceRoot, originalOutputPath);\n  }\n\n  return { config: transformedConfig || config, projectRoot, projectSourceRoot, i18n };\n}\n\n/**\n * @experimental Direct usage of this function is considered experimental.\n */\n// eslint-disable-next-line max-lines-per-function\nexport function buildWebpackBrowser(\n  options: BrowserBuilderSchema,\n  context: BuilderContext,\n  transforms: {\n    webpackConfiguration?: ExecutionTransformer<webpack.Configuration>;\n    logging?: WebpackLoggingCallback;\n    indexHtml?: IndexHtmlTransform;\n  } = {},\n): Observable<BrowserBuilderOutput> {\n  const projectName = context.target?.project;\n  if (!projectName) {\n    throw new Error('The builder requires a target.');\n  }\n\n  const baseOutputPath = path.resolve(context.workspaceRoot, options.outputPath);\n  let outputPaths: undefined | Map<string, string>;\n\n  // Check Angular version.\n  assertCompatibleAngularVersion(context.workspaceRoot);\n\n  return from(context.getProjectMetadata(projectName)).pipe(\n    switchMap(async (projectMetadata) => {\n      // Purge old build disk cache.\n      await purgeStaleBuildCache(context);\n\n      // Initialize builder\n      const initialization = await initialize(options, context, transforms.webpackConfiguration);\n\n      // Add index file to watched files.\n      if (options.watch) {\n        const indexInputFile = path.join(context.workspaceRoot, getIndexInputFile(options.index));\n        initialization.config.plugins ??= [];\n        initialization.config.plugins.push({\n          apply: (compiler: webpack.Compiler) => {\n            compiler.hooks.thisCompilation.tap('build-angular', (compilation) => {\n              compilation.fileDependencies.add(indexInputFile);\n            });\n          },\n        });\n      }\n\n      return {\n        ...initialization,\n        cacheOptions: normalizeCacheOptions(projectMetadata, context.workspaceRoot),\n      };\n    }),\n    switchMap(\n      // eslint-disable-next-line max-lines-per-function\n      ({ config, projectRoot, projectSourceRoot, i18n, cacheOptions }) => {\n        const normalizedOptimization = normalizeOptimization(options.optimization);\n\n        return runWebpack(config, context, {\n          // webpackFactory: require('webpack') as typeof webpack,\n          webpackFactory: webpackFactory as unknown as typeof webpack,\n          logging:\n            transforms.logging ||\n            ((stats, config) => {\n              if (options.verbose) {\n                context.logger.info(stats.toString(config.stats));\n              }\n            }),\n        }).pipe(\n          concatMap(\n            // eslint-disable-next-line max-lines-per-function\n            async (\n              buildEvent,\n            ): Promise<{ output: BuilderOutput; webpackStats: StatsCompilation }> => {\n              const spinner = new Spinner();\n              spinner.enabled = options.progress !== false;\n\n              const { success, emittedFiles = [], outputPath: webpackOutputPath } = buildEvent;\n              const webpackRawStats = buildEvent.webpackStats;\n              if (!webpackRawStats) {\n                throw new Error('Webpack stats build result is required.');\n              }\n\n              // Fix incorrectly set `initial` value on chunks.\n              const extraEntryPoints = [\n                ...normalizeExtraEntryPoints(options.styles || [], 'styles'),\n                ...normalizeExtraEntryPoints(options.scripts || [], 'scripts'),\n              ];\n\n              const webpackStats = {\n                ...webpackRawStats,\n                chunks: markAsyncChunksNonInitial(webpackRawStats, extraEntryPoints),\n              };\n\n              if (!success) {\n                // If using bundle downleveling then there is only one build\n                // If it fails show any diagnostic messages and bail\n                if (statsHasWarnings(webpackStats)) {\n                  context.logger.warn(statsWarningsToString(webpackStats, { colors: true }));\n                }\n                if (statsHasErrors(webpackStats)) {\n                  context.logger.error(statsErrorsToString(webpackStats, { colors: true }));\n                }\n\n                return {\n                  webpackStats: webpackRawStats,\n                  output: { success: false },\n                };\n              } else {\n                outputPaths = ensureOutputPaths(baseOutputPath, i18n);\n\n                const scriptsEntryPointName = normalizeExtraEntryPoints(\n                  options.scripts || [],\n                  'scripts',\n                ).map((x) => x.bundleName);\n\n                if (i18n.shouldInline) {\n                  const success = await i18nInlineEmittedFiles(\n                    context,\n                    emittedFiles,\n                    i18n,\n                    baseOutputPath,\n                    Array.from(outputPaths.values()),\n                    scriptsEntryPointName,\n                    webpackOutputPath,\n                    options.i18nMissingTranslation,\n                  );\n                  if (!success) {\n                    return {\n                      webpackStats: webpackRawStats,\n                      output: { success: false },\n                    };\n                  }\n                }\n\n                // Check for budget errors and display them to the user.\n                const budgets = options.budgets;\n                let budgetFailures: BudgetCalculatorResult[] | undefined;\n                if (budgets?.length) {\n                  budgetFailures = [...checkBudgets(budgets, webpackStats)];\n                  for (const { severity, message } of budgetFailures) {\n                    switch (severity) {\n                      case ThresholdSeverity.Warning:\n                        webpackStats.warnings?.push({ message });\n                        break;\n                      case ThresholdSeverity.Error:\n                        webpackStats.errors?.push({ message });\n                        break;\n                      default:\n                        assertNever(severity);\n                    }\n                  }\n                }\n\n                const buildSuccess = success && !statsHasErrors(webpackStats);\n                if (buildSuccess) {\n                  // Copy assets\n                  if (!options.watch && options.assets?.length) {\n                    spinner.start('Copying assets...');\n                    try {\n                      await copyAssets(\n                        normalizeAssetPatterns(\n                          options.assets,\n                          context.workspaceRoot,\n                          projectRoot,\n                          projectSourceRoot,\n                        ),\n                        Array.from(outputPaths.values()),\n                        context.workspaceRoot,\n                      );\n                      spinner.succeed('Copying assets complete.');\n                    } catch (err) {\n                      spinner.fail(colors.redBright('Copying of assets failed.'));\n                      assertIsError(err);\n\n                      return {\n                        output: {\n                          success: false,\n                          error: 'Unable to copy assets: ' + err.message,\n                        },\n                        webpackStats: webpackRawStats,\n                      };\n                    }\n                  }\n\n                  if (options.index) {\n                    spinner.start('Generating index html...');\n\n                    const entrypoints = generateEntryPoints({\n                      scripts: options.scripts ?? [],\n                      styles: options.styles ?? [],\n                    });\n\n                    const indexHtmlGenerator = new IndexHtmlGenerator({\n                      cache: cacheOptions,\n                      indexPath: path.join(context.workspaceRoot, getIndexInputFile(options.index)),\n                      entrypoints,\n                      deployUrl: options.deployUrl,\n                      sri: options.subresourceIntegrity,\n                      optimization: normalizedOptimization,\n                      crossOrigin: options.crossOrigin,\n                      postTransform: transforms.indexHtml,\n                    });\n\n                    let hasErrors = false;\n                    for (const [locale, outputPath] of outputPaths.entries()) {\n                      try {\n                        const { content, warnings, errors } = await indexHtmlGenerator.process({\n                          baseHref: getLocaleBaseHref(i18n, locale) ?? options.baseHref,\n                          // i18nLocale is used when Ivy is disabled\n                          lang: locale || undefined,\n                          outputPath,\n                          files: mapEmittedFilesToFileInfo(emittedFiles),\n                        });\n\n                        if (warnings.length || errors.length) {\n                          spinner.stop();\n                          warnings.forEach((m) => context.logger.warn(m));\n                          errors.forEach((m) => {\n                            context.logger.error(m);\n                            hasErrors = true;\n                          });\n                          spinner.start();\n                        }\n\n                        const indexOutput = path.join(\n                          outputPath,\n                          getIndexOutputFile(options.index),\n                        );\n                        await fs.promises.mkdir(path.dirname(indexOutput), { recursive: true });\n                        await fs.promises.writeFile(indexOutput, content);\n                      } catch (error) {\n                        spinner.fail('Index html generation failed.');\n                        assertIsError(error);\n\n                        return {\n                          webpackStats: webpackRawStats,\n                          output: { success: false, error: error.message },\n                        };\n                      }\n                    }\n\n                    if (hasErrors) {\n                      spinner.fail('Index html generation failed.');\n\n                      return {\n                        webpackStats: webpackRawStats,\n                        output: { success: false },\n                      };\n                    } else {\n                      spinner.succeed('Index html generation complete.');\n                    }\n                  }\n\n                  if (options.serviceWorker) {\n                    spinner.start('Generating service worker...');\n                    for (const [locale, outputPath] of outputPaths.entries()) {\n                      try {\n                        await augmentAppWithServiceWorker(\n                          projectRoot,\n                          context.workspaceRoot,\n                          outputPath,\n                          getLocaleBaseHref(i18n, locale) ?? options.baseHref ?? '/',\n                          options.ngswConfigPath,\n                        );\n                      } catch (error) {\n                        spinner.fail('Service worker generation failed.');\n                        assertIsError(error);\n\n                        return {\n                          webpackStats: webpackRawStats,\n                          output: { success: false, error: error.message },\n                        };\n                      }\n                    }\n\n                    spinner.succeed('Service worker generation complete.');\n                  }\n                }\n\n                webpackStatsLogger(context.logger, webpackStats, config, budgetFailures);\n\n                return {\n                  webpackStats: webpackRawStats,\n                  output: { success: buildSuccess },\n                };\n              }\n            },\n          ),\n          map(\n            ({ output: event, webpackStats }) =>\n              ({\n                ...event,\n                stats: generateBuildEventStats(webpackStats, options),\n                baseOutputPath,\n                outputs: (outputPaths &&\n                  [...outputPaths.entries()].map(([locale, path]) => ({\n                    locale,\n                    path,\n                    baseHref: getLocaleBaseHref(i18n, locale) ?? options.baseHref,\n                  }))) || {\n                  path: baseOutputPath,\n                  baseHref: options.baseHref,\n                },\n              } as BrowserBuilderOutput),\n          ),\n        );\n      },\n    ),\n  );\n\n  function getLocaleBaseHref(i18n: I18nOptions, locale: string): string | undefined {\n    if (i18n.locales[locale] && i18n.locales[locale]?.baseHref !== '') {\n      return urlJoin(options.baseHref || '', i18n.locales[locale].baseHref ?? `/${locale}/`);\n    }\n\n    return undefined;\n  }\n}\n\nfunction assertNever(input: never): never {\n  throw new Error(\n    `Unexpected call to assertNever() with input: ${JSON.stringify(\n      input,\n      null /* replacer */,\n      4 /* tabSize */,\n    )}`,\n  );\n}\n\nfunction mapEmittedFilesToFileInfo(files: EmittedFiles[] = []): FileInfo[] {\n  const filteredFiles: FileInfo[] = [];\n  for (const { file, name, extension, initial } of files) {\n    if (name && initial) {\n      filteredFiles.push({ file, extension, name });\n    }\n  }\n\n  return filteredFiles;\n}\n\nexport default createBuilder<BrowserBuilderSchema>(buildWebpackBrowser);\n"]} diff --git a/artifacts/build-angular/src/builders/browser-rspack/plugins/progress-plugin.d.ts b/artifacts/build-angular/src/builders/browser-rspack/plugins/progress-plugin.d.ts new file mode 100644 index 00000000..8dc018b4 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-rspack/plugins/progress-plugin.d.ts @@ -0,0 +1,11 @@ +/** + * @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 { ProgressPlugin as WebpackProgressPlugin } from './webpack/webpack-progress-plugin'; +export declare class ProgressPlugin extends WebpackProgressPlugin { + constructor(platform: 'server' | 'browser'); +} diff --git a/artifacts/build-angular/src/builders/browser-rspack/plugins/progress-plugin.js b/artifacts/build-angular/src/builders/browser-rspack/plugins/progress-plugin.js new file mode 100644 index 00000000..88f02f43 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-rspack/plugins/progress-plugin.js @@ -0,0 +1,39 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ProgressPlugin = void 0; +const webpack_progress_plugin_1 = require("./webpack/webpack-progress-plugin"); +const spinner_1 = require("../../../utils/spinner"); +class ProgressPlugin extends webpack_progress_plugin_1.ProgressPlugin { + constructor(platform) { + const platformCapitalFirst = platform.replace(/^\w/, (s) => s.toUpperCase()); + const spinner = new spinner_1.Spinner(); + spinner.start(`Generating ${platform} application bundles (phase: setup)...`); + super({ + handler: (percentage, message) => { + const phase = message ? ` (phase: ${message})` : ''; + spinner.text = `Generating ${platform} application bundles${phase}...`; + switch (percentage) { + case 1: + if (spinner.isSpinning) { + spinner.succeed(`${platformCapitalFirst} application bundle generation complete.`); + } + break; + case 0: + if (!spinner.isSpinning) { + spinner.start(); + } + break; + } + }, + }); + } +} +exports.ProgressPlugin = ProgressPlugin; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-rspack/plugins/webpack/webpack-progress-plugin.d.ts b/artifacts/build-angular/src/builders/browser-rspack/plugins/webpack/webpack-progress-plugin.d.ts new file mode 100644 index 00000000..7c92158d --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-rspack/plugins/webpack/webpack-progress-plugin.d.ts @@ -0,0 +1,28 @@ +export declare class ProgressPlugin { + /** + * @param {Compiler} compiler the current compiler + * @returns {ReportProgress} a progress reporter, if any + */ + static getReporter(compiler: any): any; + /** + * @param {ProgressPluginArgument} options options + */ + constructor(options?: {}); + /** + * @param {Compiler | MultiCompiler} compiler webpack compiler + * @returns {void} + */ + apply(compiler: any): void; + /** + * @param {MultiCompiler} compiler webpack multi-compiler + * @param {HandlerFunction} handler function that executes for every progress step + * @returns {void} + */ + _applyOnMultiCompiler(compiler: any, handler: any): void; + /** + * @param {Compiler} compiler webpack compiler + * @param {HandlerFunction} handler function that executes for every progress step + * @returns {void} + */ + _applyOnCompiler(compiler: any, handler: any): void; +} diff --git a/artifacts/build-angular/src/builders/browser-rspack/plugins/webpack/webpack-progress-plugin.js b/artifacts/build-angular/src/builders/browser-rspack/plugins/webpack/webpack-progress-plugin.js new file mode 100644 index 00000000..f8dabfba --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-rspack/plugins/webpack/webpack-progress-plugin.js @@ -0,0 +1,518 @@ +// @ts-nocheck +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +'use strict'; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ProgressPlugin = void 0; +const core_1 = require("@rspack/core"); +// const createSchemaValidation = require("./util/create-schema-validation"); +// const { contextify } = require("./util/identifier"); +/** @typedef {import("../declarations/plugins/ProgressPlugin").HandlerFunction} HandlerFunction */ +/** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginArgument} ProgressPluginArgument */ +/** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginOptions} ProgressPluginOptions */ +/*const validate = createSchemaValidation( + require("../schemas/plugins/ProgressPlugin.check.js"), + () => require("../schemas/plugins/ProgressPlugin.json"), + { + name: "Progress Plugin", + baseDataPath: "options" + } +);*/ +const validate = (options) => { }; +const median3 = (a, b, c) => { + return a + b + c - Math.max(a, b, c) - Math.min(a, b, c); +}; +const createDefaultHandler = (profile, logger) => { + /** @type {{ value: string, time: number }[]} */ + const lastStateInfo = []; + const defaultHandler = (percentage, msg, ...args) => { + if (profile) { + if (percentage === 0) { + lastStateInfo.length = 0; + } + const fullState = [msg, ...args]; + const state = fullState.map((s) => s.replace(/\d+\/\d+ /g, '')); + const now = Date.now(); + const len = Math.max(state.length, lastStateInfo.length); + for (let i = len; i >= 0; i--) { + const stateItem = i < state.length ? state[i] : undefined; + const lastStateItem = i < lastStateInfo.length ? lastStateInfo[i] : undefined; + if (lastStateItem) { + if (stateItem !== lastStateItem.value) { + const diff = now - lastStateItem.time; + if (lastStateItem.value) { + let reportState = lastStateItem.value; + if (i > 0) { + reportState = lastStateInfo[i - 1].value + ' > ' + reportState; + } + const stateMsg = `${' | '.repeat(i)}${diff} ms ${reportState}`; + const d = diff; + // This depends on timing so we ignore it for coverage + /* istanbul ignore next */ + { + if (d > 10000) { + logger.error(stateMsg); + } + else if (d > 1000) { + logger.warn(stateMsg); + } + else if (d > 10) { + logger.info(stateMsg); + } + else if (d > 5) { + logger.log(stateMsg); + } + else { + logger.debug(stateMsg); + } + } + } + if (stateItem === undefined) { + lastStateInfo.length = i; + } + else { + lastStateItem.value = stateItem; + lastStateItem.time = now; + lastStateInfo.length = i + 1; + } + } + } + else { + lastStateInfo[i] = { + value: stateItem, + time: now, + }; + } + } + } + logger.status(`${Math.floor(percentage * 100)}%`, msg, ...args); + if (percentage === 1 || (!msg && args.length === 0)) + logger.status(); + }; + return defaultHandler; +}; +/** + * @callback ReportProgress + * @param {number} p + * @param {...string} [args] + * @returns {void} + */ +/** @type {WeakMap} */ +const progressReporters = new WeakMap(); +class ProgressPlugin { + /** + * @param {Compiler} compiler the current compiler + * @returns {ReportProgress} a progress reporter, if any + */ + static getReporter(compiler) { + return progressReporters.get(compiler); + } + /** + * @param {ProgressPluginArgument} options options + */ + constructor(options = {}) { + if (typeof options === 'function') { + options = { + handler: options, + }; + } + validate(options); + options = { ...ProgressPlugin.defaultOptions, ...options }; + this.profile = options.profile; + this.handler = options.handler; + this.modulesCount = options.modulesCount; + this.dependenciesCount = options.dependenciesCount; + this.showEntries = options.entries; + this.showModules = options.modules; + this.showDependencies = options.dependencies; + this.showActiveModules = options.activeModules; + this.percentBy = options.percentBy; + } + /** + * @param {Compiler | MultiCompiler} compiler webpack compiler + * @returns {void} + */ + apply(compiler) { + const handler = this.handler || + createDefaultHandler(this.profile, compiler.getInfrastructureLogger('webpack.Progress')); + if (compiler instanceof core_1.MultiCompiler) { + this._applyOnMultiCompiler(compiler, handler); + } + else if (compiler instanceof core_1.Compiler) { + this._applyOnCompiler(compiler, handler); + } + } + /** + * @param {MultiCompiler} compiler webpack multi-compiler + * @param {HandlerFunction} handler function that executes for every progress step + * @returns {void} + */ + _applyOnMultiCompiler(compiler, handler) { + const states = compiler.compilers.map(() => /** @type {[number, ...string[]]} */ [0]); + compiler.compilers.forEach((compiler, idx) => { + new ProgressPlugin((p, msg, ...args) => { + states[idx] = [p, msg, ...args]; + let sum = 0; + for (const [p] of states) + sum += p; + handler(sum / states.length, `[${idx}] ${msg}`, ...args); + }).apply(compiler); + }); + } + /** + * @param {Compiler} compiler webpack compiler + * @param {HandlerFunction} handler function that executes for every progress step + * @returns {void} + */ + _applyOnCompiler(compiler, handler) { + const showEntries = this.showEntries; + const showModules = this.showModules; + const showDependencies = this.showDependencies; + const showActiveModules = this.showActiveModules; + let lastActiveModule = ''; + let currentLoader = ''; + let lastModulesCount = 0; + let lastDependenciesCount = 0; + let lastEntriesCount = 0; + let modulesCount = 0; + let dependenciesCount = 0; + let entriesCount = 1; + let doneModules = 0; + let doneDependencies = 0; + let doneEntries = 0; + const activeModules = new Set(); + let lastUpdate = 0; + const updateThrottled = () => { + if (lastUpdate + 500 < Date.now()) + update(); + }; + const update = () => { + /** @type {string[]} */ + const items = []; + const percentByModules = doneModules / Math.max(lastModulesCount || this.modulesCount || 1, modulesCount); + const percentByEntries = doneEntries / Math.max(lastEntriesCount || this.dependenciesCount || 1, entriesCount); + const percentByDependencies = doneDependencies / Math.max(lastDependenciesCount || 1, dependenciesCount); + let percentageFactor; + switch (this.percentBy) { + case 'entries': + percentageFactor = percentByEntries; + break; + case 'dependencies': + percentageFactor = percentByDependencies; + break; + case 'modules': + percentageFactor = percentByModules; + break; + default: + percentageFactor = median3(percentByModules, percentByEntries, percentByDependencies); + } + const percentage = 0.1 + percentageFactor * 0.55; + if (currentLoader) { + items.push(`import loader ${contextify(compiler.context, currentLoader, compiler.root)}`); + } + else { + const statItems = []; + if (showEntries) { + statItems.push(`${doneEntries}/${entriesCount} entries`); + } + if (showDependencies) { + statItems.push(`${doneDependencies}/${dependenciesCount} dependencies`); + } + if (showModules) { + statItems.push(`${doneModules}/${modulesCount} modules`); + } + if (showActiveModules) { + statItems.push(`${activeModules.size} active`); + } + if (statItems.length > 0) { + items.push(statItems.join(' ')); + } + if (showActiveModules) { + items.push(lastActiveModule); + } + } + handler(percentage, 'building', ...items); + lastUpdate = Date.now(); + }; + const factorizeAdd = () => { + dependenciesCount++; + if (dependenciesCount < 50 || dependenciesCount % 100 === 0) + updateThrottled(); + }; + const factorizeDone = () => { + doneDependencies++; + if (doneDependencies < 50 || doneDependencies % 100 === 0) + updateThrottled(); + }; + const moduleAdd = () => { + modulesCount++; + if (modulesCount < 50 || modulesCount % 100 === 0) + updateThrottled(); + }; + // only used when showActiveModules is set + const moduleBuild = (module) => { + const ident = module.identifier(); + if (ident) { + activeModules.add(ident); + lastActiveModule = ident; + update(); + } + }; + const entryAdd = (entry, options) => { + entriesCount++; + if (entriesCount < 5 || entriesCount % 10 === 0) + updateThrottled(); + }; + const moduleDone = (module) => { + doneModules++; + if (showActiveModules) { + const ident = module.identifier(); + if (ident) { + activeModules.delete(ident); + if (lastActiveModule === ident) { + lastActiveModule = ''; + for (const m of activeModules) { + lastActiveModule = m; + } + update(); + return; + } + } + } + if (doneModules < 50 || doneModules % 100 === 0) + updateThrottled(); + }; + const entryDone = (entry, options) => { + doneEntries++; + update(); + }; + const cache = compiler.getCache('ProgressPlugin').getItemCache('counts', null); + let cacheGetPromise; + compiler.hooks.beforeCompile.tap('ProgressPlugin', () => { + if (!cacheGetPromise) { + cacheGetPromise = cache.getPromise().then((data) => { + if (data) { + lastModulesCount = lastModulesCount || data.modulesCount; + lastDependenciesCount = lastDependenciesCount || data.dependenciesCount; + } + return data; + }, (err) => { + // Ignore error + }); + } + }); + compiler.hooks.afterCompile.tapPromise('ProgressPlugin', (compilation) => { + if (compilation.compiler.isChild()) + return Promise.resolve(); + return cacheGetPromise.then(async (oldData) => { + if (!oldData || + oldData.modulesCount !== modulesCount || + oldData.dependenciesCount !== dependenciesCount) { + await cache.storePromise({ modulesCount, dependenciesCount }); + } + }); + }); + compiler.hooks.compilation.tap('ProgressPlugin', (compilation) => { + if (compilation.compiler.isChild()) + return; + lastModulesCount = modulesCount; + lastEntriesCount = entriesCount; + lastDependenciesCount = dependenciesCount; + modulesCount = dependenciesCount = entriesCount = 0; + doneModules = doneDependencies = doneEntries = 0; + compilation.factorizeQueue.hooks.added.tap('ProgressPlugin', factorizeAdd); + compilation.factorizeQueue.hooks.result.tap('ProgressPlugin', factorizeDone); + compilation.addModuleQueue.hooks.added.tap('ProgressPlugin', moduleAdd); + compilation.processDependenciesQueue.hooks.result.tap('ProgressPlugin', moduleDone); + if (showActiveModules) { + compilation.hooks.buildModule.tap('ProgressPlugin', moduleBuild); + } + compilation.hooks.addEntry.tap('ProgressPlugin', entryAdd); + compilation.hooks.failedEntry.tap('ProgressPlugin', entryDone); + compilation.hooks.succeedEntry.tap('ProgressPlugin', entryDone); + // avoid dynamic require if bundled with webpack + // @ts-expect-error + if (typeof __webpack_require__ !== 'function') { + const requiredLoaders = new Set(); + core_1.NormalModule.getCompilationHooks(compilation).beforeLoaders.tap('ProgressPlugin', (loaders) => { + for (const loader of loaders) { + if (loader.type !== 'module' && !requiredLoaders.has(loader.loader)) { + requiredLoaders.add(loader.loader); + currentLoader = loader.loader; + update(); + require(loader.loader); + } + } + if (currentLoader) { + currentLoader = ''; + update(); + } + }); + } + const hooks = { + finishModules: 'finish module graph', + seal: 'plugins', + optimizeDependencies: 'dependencies optimization', + afterOptimizeDependencies: 'after dependencies optimization', + beforeChunks: 'chunk graph', + afterChunks: 'after chunk graph', + optimize: 'optimizing', + optimizeModules: 'module optimization', + afterOptimizeModules: 'after module optimization', + optimizeChunks: 'chunk optimization', + afterOptimizeChunks: 'after chunk optimization', + optimizeTree: 'module and chunk tree optimization', + afterOptimizeTree: 'after module and chunk tree optimization', + optimizeChunkModules: 'chunk modules optimization', + afterOptimizeChunkModules: 'after chunk modules optimization', + reviveModules: 'module reviving', + beforeModuleIds: 'before module ids', + moduleIds: 'module ids', + optimizeModuleIds: 'module id optimization', + afterOptimizeModuleIds: 'module id optimization', + reviveChunks: 'chunk reviving', + beforeChunkIds: 'before chunk ids', + chunkIds: 'chunk ids', + optimizeChunkIds: 'chunk id optimization', + afterOptimizeChunkIds: 'after chunk id optimization', + recordModules: 'record modules', + recordChunks: 'record chunks', + beforeModuleHash: 'module hashing', + beforeCodeGeneration: 'code generation', + beforeRuntimeRequirements: 'runtime requirements', + beforeHash: 'hashing', + afterHash: 'after hashing', + recordHash: 'record hash', + beforeModuleAssets: 'module assets processing', + beforeChunkAssets: 'chunk assets processing', + processAssets: 'asset processing', + afterProcessAssets: 'after asset optimization', + record: 'recording', + afterSeal: 'after seal', + }; + const numberOfHooks = Object.keys(hooks).length; + Object.keys(hooks).forEach((name, idx) => { + const title = hooks[name]; + const percentage = (idx / numberOfHooks) * 0.25 + 0.7; + compilation.hooks[name].intercept({ + name: 'ProgressPlugin', + call() { + handler(percentage, 'sealing', title); + }, + done() { + progressReporters.set(compiler, undefined); + handler(percentage, 'sealing', title); + }, + result() { + handler(percentage, 'sealing', title); + }, + error() { + handler(percentage, 'sealing', title); + }, + tap(tap) { + // p is percentage from 0 to 1 + // args is any number of messages in a hierarchical matter + progressReporters.set(compilation.compiler, (p, ...args) => { + handler(percentage, 'sealing', title, tap.name, ...args); + }); + handler(percentage, 'sealing', title, tap.name); + }, + }); + }); + }); + compiler.hooks.make.intercept({ + name: 'ProgressPlugin', + call() { + handler(0.1, 'building'); + }, + done() { + handler(0.65, 'building'); + }, + }); + const interceptHook = (hook, progress, category, name) => { + hook.intercept({ + name: 'ProgressPlugin', + call() { + handler(progress, category, name); + }, + done() { + progressReporters.set(compiler, undefined); + handler(progress, category, name); + }, + result() { + handler(progress, category, name); + }, + error() { + handler(progress, category, name); + }, + tap(tap) { + progressReporters.set(compiler, (p, ...args) => { + handler(progress, category, name, tap.name, ...args); + }); + handler(progress, category, name, tap.name); + }, + }); + }; + compiler.cache.hooks.endIdle.intercept({ + name: 'ProgressPlugin', + call() { + handler(0, ''); + }, + }); + interceptHook(compiler.cache.hooks.endIdle, 0.01, 'cache', 'end idle'); + compiler.hooks.beforeRun.intercept({ + name: 'ProgressPlugin', + call() { + handler(0, ''); + }, + }); + interceptHook(compiler.hooks.beforeRun, 0.01, 'setup', 'before run'); + interceptHook(compiler.hooks.run, 0.02, 'setup', 'run'); + interceptHook(compiler.hooks.watchRun, 0.03, 'setup', 'watch run'); + interceptHook(compiler.hooks.normalModuleFactory, 0.04, 'setup', 'normal module factory'); + interceptHook(compiler.hooks.contextModuleFactory, 0.05, 'setup', 'context module factory'); + interceptHook(compiler.hooks.beforeCompile, 0.06, 'setup', 'before compile'); + interceptHook(compiler.hooks.compile, 0.07, 'setup', 'compile'); + interceptHook(compiler.hooks.thisCompilation, 0.08, 'setup', 'compilation'); + interceptHook(compiler.hooks.compilation, 0.09, 'setup', 'compilation'); + interceptHook(compiler.hooks.finishMake, 0.69, 'building', 'finish'); + interceptHook(compiler.hooks.emit, 0.95, 'emitting', 'emit'); + interceptHook(compiler.hooks.afterEmit, 0.98, 'emitting', 'after emit'); + interceptHook(compiler.hooks.done, 0.99, 'done', 'plugins'); + compiler.hooks.done.intercept({ + name: 'ProgressPlugin', + done() { + handler(0.99, ''); + }, + }); + interceptHook(compiler.cache.hooks.storeBuildDependencies, 0.99, 'cache', 'store build dependencies'); + interceptHook(compiler.cache.hooks.shutdown, 0.99, 'cache', 'shutdown'); + interceptHook(compiler.cache.hooks.beginIdle, 0.99, 'cache', 'begin idle'); + interceptHook(compiler.hooks.watchClose, 0.99, 'end', 'closing watch compilation'); + compiler.cache.hooks.beginIdle.intercept({ + name: 'ProgressPlugin', + done() { + handler(1, ''); + }, + }); + compiler.cache.hooks.shutdown.intercept({ + name: 'ProgressPlugin', + done() { + handler(1, ''); + }, + }); + } +} +exports.ProgressPlugin = ProgressPlugin; +ProgressPlugin.defaultOptions = { + profile: false, + modulesCount: 5000, + dependenciesCount: 10000, + modules: true, + dependencies: true, + activeModules: false, + entries: true, +}; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"webpack-progress-plugin.js","sourceRoot":"","sources":["../../../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-rspack/plugins/webpack/webpack-progress-plugin.ts"],"names":[],"mappings":"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","sourcesContent":["// @ts-nocheck\n/*\n\tMIT License http://www.opensource.org/licenses/mit-license.php\n\tAuthor Tobias Koppers @sokra\n*/\n\n'use strict';\n\nimport { Compiler, MultiCompiler, NormalModule } from '@rspack/core';\n// const createSchemaValidation = require(\"./util/create-schema-validation\");\n// const { contextify } = require(\"./util/identifier\");\n\n/** @typedef {import(\"../declarations/plugins/ProgressPlugin\").HandlerFunction} HandlerFunction */\n/** @typedef {import(\"../declarations/plugins/ProgressPlugin\").ProgressPluginArgument} ProgressPluginArgument */\n/** @typedef {import(\"../declarations/plugins/ProgressPlugin\").ProgressPluginOptions} ProgressPluginOptions */\n\n/*const validate = createSchemaValidation(\n  require(\"../schemas/plugins/ProgressPlugin.check.js\"),\n  () => require(\"../schemas/plugins/ProgressPlugin.json\"),\n  {\n    name: \"Progress Plugin\",\n    baseDataPath: \"options\"\n  }\n);*/\n\nconst validate = (options) => {};\n\nconst median3 = (a, b, c) => {\n  return a + b + c - Math.max(a, b, c) - Math.min(a, b, c);\n};\n\nconst createDefaultHandler = (profile, logger) => {\n  /** @type {{ value: string, time: number }[]} */\n  const lastStateInfo = [];\n\n  const defaultHandler = (percentage, msg, ...args) => {\n    if (profile) {\n      if (percentage === 0) {\n        lastStateInfo.length = 0;\n      }\n      const fullState = [msg, ...args];\n      const state = fullState.map((s) => s.replace(/\\d+\\/\\d+ /g, ''));\n      const now = Date.now();\n      const len = Math.max(state.length, lastStateInfo.length);\n      for (let i = len; i >= 0; i--) {\n        const stateItem = i < state.length ? state[i] : undefined;\n        const lastStateItem = i < lastStateInfo.length ? lastStateInfo[i] : undefined;\n        if (lastStateItem) {\n          if (stateItem !== lastStateItem.value) {\n            const diff = now - lastStateItem.time;\n            if (lastStateItem.value) {\n              let reportState = lastStateItem.value;\n              if (i > 0) {\n                reportState = lastStateInfo[i - 1].value + ' > ' + reportState;\n              }\n              const stateMsg = `${' | '.repeat(i)}${diff} ms ${reportState}`;\n              const d = diff;\n              // This depends on timing so we ignore it for coverage\n              /* istanbul ignore next */\n              {\n                if (d > 10000) {\n                  logger.error(stateMsg);\n                } else if (d > 1000) {\n                  logger.warn(stateMsg);\n                } else if (d > 10) {\n                  logger.info(stateMsg);\n                } else if (d > 5) {\n                  logger.log(stateMsg);\n                } else {\n                  logger.debug(stateMsg);\n                }\n              }\n            }\n            if (stateItem === undefined) {\n              lastStateInfo.length = i;\n            } else {\n              lastStateItem.value = stateItem;\n              lastStateItem.time = now;\n              lastStateInfo.length = i + 1;\n            }\n          }\n        } else {\n          lastStateInfo[i] = {\n            value: stateItem,\n            time: now,\n          };\n        }\n      }\n    }\n    logger.status(`${Math.floor(percentage * 100)}%`, msg, ...args);\n    if (percentage === 1 || (!msg && args.length === 0)) logger.status();\n  };\n\n  return defaultHandler;\n};\n\n/**\n * @callback ReportProgress\n * @param {number} p\n * @param {...string} [args]\n * @returns {void}\n */\n\n/** @type {WeakMap<Compiler,ReportProgress>} */\nconst progressReporters = new WeakMap();\n\nexport class ProgressPlugin {\n  /**\n   * @param {Compiler} compiler the current compiler\n   * @returns {ReportProgress} a progress reporter, if any\n   */\n  static getReporter(compiler) {\n    return progressReporters.get(compiler);\n  }\n\n  /**\n   * @param {ProgressPluginArgument} options options\n   */\n  constructor(options = {}) {\n    if (typeof options === 'function') {\n      options = {\n        handler: options,\n      };\n    }\n\n    validate(options);\n    options = { ...ProgressPlugin.defaultOptions, ...options };\n\n    this.profile = options.profile;\n    this.handler = options.handler;\n    this.modulesCount = options.modulesCount;\n    this.dependenciesCount = options.dependenciesCount;\n    this.showEntries = options.entries;\n    this.showModules = options.modules;\n    this.showDependencies = options.dependencies;\n    this.showActiveModules = options.activeModules;\n    this.percentBy = options.percentBy;\n  }\n\n  /**\n   * @param {Compiler | MultiCompiler} compiler webpack compiler\n   * @returns {void}\n   */\n  apply(compiler) {\n    const handler =\n      this.handler ||\n      createDefaultHandler(this.profile, compiler.getInfrastructureLogger('webpack.Progress'));\n    if (compiler instanceof MultiCompiler) {\n      this._applyOnMultiCompiler(compiler, handler);\n    } else if (compiler instanceof Compiler) {\n      this._applyOnCompiler(compiler, handler);\n    }\n  }\n\n  /**\n   * @param {MultiCompiler} compiler webpack multi-compiler\n   * @param {HandlerFunction} handler function that executes for every progress step\n   * @returns {void}\n   */\n  _applyOnMultiCompiler(compiler, handler) {\n    const states = compiler.compilers.map(() => /** @type {[number, ...string[]]} */ [0]);\n    compiler.compilers.forEach((compiler, idx) => {\n      new ProgressPlugin((p, msg, ...args) => {\n        states[idx] = [p, msg, ...args];\n        let sum = 0;\n        for (const [p] of states) sum += p;\n        handler(sum / states.length, `[${idx}] ${msg}`, ...args);\n      }).apply(compiler);\n    });\n  }\n\n  /**\n   * @param {Compiler} compiler webpack compiler\n   * @param {HandlerFunction} handler function that executes for every progress step\n   * @returns {void}\n   */\n  _applyOnCompiler(compiler, handler) {\n    const showEntries = this.showEntries;\n    const showModules = this.showModules;\n    const showDependencies = this.showDependencies;\n    const showActiveModules = this.showActiveModules;\n    let lastActiveModule = '';\n    let currentLoader = '';\n    let lastModulesCount = 0;\n    let lastDependenciesCount = 0;\n    let lastEntriesCount = 0;\n    let modulesCount = 0;\n    let dependenciesCount = 0;\n    let entriesCount = 1;\n    let doneModules = 0;\n    let doneDependencies = 0;\n    let doneEntries = 0;\n    const activeModules = new Set();\n    let lastUpdate = 0;\n\n    const updateThrottled = () => {\n      if (lastUpdate + 500 < Date.now()) update();\n    };\n\n    const update = () => {\n      /** @type {string[]} */\n      const items = [];\n      const percentByModules =\n        doneModules / Math.max(lastModulesCount || this.modulesCount || 1, modulesCount);\n      const percentByEntries =\n        doneEntries / Math.max(lastEntriesCount || this.dependenciesCount || 1, entriesCount);\n      const percentByDependencies =\n        doneDependencies / Math.max(lastDependenciesCount || 1, dependenciesCount);\n      let percentageFactor;\n\n      switch (this.percentBy) {\n        case 'entries':\n          percentageFactor = percentByEntries;\n          break;\n        case 'dependencies':\n          percentageFactor = percentByDependencies;\n          break;\n        case 'modules':\n          percentageFactor = percentByModules;\n          break;\n        default:\n          percentageFactor = median3(percentByModules, percentByEntries, percentByDependencies);\n      }\n\n      const percentage = 0.1 + percentageFactor * 0.55;\n\n      if (currentLoader) {\n        items.push(`import loader ${contextify(compiler.context, currentLoader, compiler.root)}`);\n      } else {\n        const statItems = [];\n        if (showEntries) {\n          statItems.push(`${doneEntries}/${entriesCount} entries`);\n        }\n        if (showDependencies) {\n          statItems.push(`${doneDependencies}/${dependenciesCount} dependencies`);\n        }\n        if (showModules) {\n          statItems.push(`${doneModules}/${modulesCount} modules`);\n        }\n        if (showActiveModules) {\n          statItems.push(`${activeModules.size} active`);\n        }\n        if (statItems.length > 0) {\n          items.push(statItems.join(' '));\n        }\n        if (showActiveModules) {\n          items.push(lastActiveModule);\n        }\n      }\n      handler(percentage, 'building', ...items);\n      lastUpdate = Date.now();\n    };\n\n    const factorizeAdd = () => {\n      dependenciesCount++;\n      if (dependenciesCount < 50 || dependenciesCount % 100 === 0) updateThrottled();\n    };\n\n    const factorizeDone = () => {\n      doneDependencies++;\n      if (doneDependencies < 50 || doneDependencies % 100 === 0) updateThrottled();\n    };\n\n    const moduleAdd = () => {\n      modulesCount++;\n      if (modulesCount < 50 || modulesCount % 100 === 0) updateThrottled();\n    };\n\n    // only used when showActiveModules is set\n    const moduleBuild = (module) => {\n      const ident = module.identifier();\n      if (ident) {\n        activeModules.add(ident);\n        lastActiveModule = ident;\n        update();\n      }\n    };\n\n    const entryAdd = (entry, options) => {\n      entriesCount++;\n      if (entriesCount < 5 || entriesCount % 10 === 0) updateThrottled();\n    };\n\n    const moduleDone = (module) => {\n      doneModules++;\n      if (showActiveModules) {\n        const ident = module.identifier();\n        if (ident) {\n          activeModules.delete(ident);\n          if (lastActiveModule === ident) {\n            lastActiveModule = '';\n            for (const m of activeModules) {\n              lastActiveModule = m;\n            }\n            update();\n            return;\n          }\n        }\n      }\n      if (doneModules < 50 || doneModules % 100 === 0) updateThrottled();\n    };\n\n    const entryDone = (entry, options) => {\n      doneEntries++;\n      update();\n    };\n\n    const cache = compiler.getCache('ProgressPlugin').getItemCache('counts', null);\n\n    let cacheGetPromise;\n\n    compiler.hooks.beforeCompile.tap('ProgressPlugin', () => {\n      if (!cacheGetPromise) {\n        cacheGetPromise = cache.getPromise().then(\n          (data) => {\n            if (data) {\n              lastModulesCount = lastModulesCount || data.modulesCount;\n              lastDependenciesCount = lastDependenciesCount || data.dependenciesCount;\n            }\n            return data;\n          },\n          (err) => {\n            // Ignore error\n          },\n        );\n      }\n    });\n\n    compiler.hooks.afterCompile.tapPromise('ProgressPlugin', (compilation) => {\n      if (compilation.compiler.isChild()) return Promise.resolve();\n      return cacheGetPromise.then(async (oldData) => {\n        if (\n          !oldData ||\n          oldData.modulesCount !== modulesCount ||\n          oldData.dependenciesCount !== dependenciesCount\n        ) {\n          await cache.storePromise({ modulesCount, dependenciesCount });\n        }\n      });\n    });\n\n    compiler.hooks.compilation.tap('ProgressPlugin', (compilation) => {\n      if (compilation.compiler.isChild()) return;\n      lastModulesCount = modulesCount;\n      lastEntriesCount = entriesCount;\n      lastDependenciesCount = dependenciesCount;\n      modulesCount = dependenciesCount = entriesCount = 0;\n      doneModules = doneDependencies = doneEntries = 0;\n\n      compilation.factorizeQueue.hooks.added.tap('ProgressPlugin', factorizeAdd);\n      compilation.factorizeQueue.hooks.result.tap('ProgressPlugin', factorizeDone);\n\n      compilation.addModuleQueue.hooks.added.tap('ProgressPlugin', moduleAdd);\n      compilation.processDependenciesQueue.hooks.result.tap('ProgressPlugin', moduleDone);\n\n      if (showActiveModules) {\n        compilation.hooks.buildModule.tap('ProgressPlugin', moduleBuild);\n      }\n\n      compilation.hooks.addEntry.tap('ProgressPlugin', entryAdd);\n      compilation.hooks.failedEntry.tap('ProgressPlugin', entryDone);\n      compilation.hooks.succeedEntry.tap('ProgressPlugin', entryDone);\n\n      // avoid dynamic require if bundled with webpack\n      // @ts-expect-error\n      if (typeof __webpack_require__ !== 'function') {\n        const requiredLoaders = new Set();\n        NormalModule.getCompilationHooks(compilation).beforeLoaders.tap(\n          'ProgressPlugin',\n          (loaders) => {\n            for (const loader of loaders) {\n              if (loader.type !== 'module' && !requiredLoaders.has(loader.loader)) {\n                requiredLoaders.add(loader.loader);\n                currentLoader = loader.loader;\n                update();\n                require(loader.loader);\n              }\n            }\n            if (currentLoader) {\n              currentLoader = '';\n              update();\n            }\n          },\n        );\n      }\n\n      const hooks = {\n        finishModules: 'finish module graph',\n        seal: 'plugins',\n        optimizeDependencies: 'dependencies optimization',\n        afterOptimizeDependencies: 'after dependencies optimization',\n        beforeChunks: 'chunk graph',\n        afterChunks: 'after chunk graph',\n        optimize: 'optimizing',\n        optimizeModules: 'module optimization',\n        afterOptimizeModules: 'after module optimization',\n        optimizeChunks: 'chunk optimization',\n        afterOptimizeChunks: 'after chunk optimization',\n        optimizeTree: 'module and chunk tree optimization',\n        afterOptimizeTree: 'after module and chunk tree optimization',\n        optimizeChunkModules: 'chunk modules optimization',\n        afterOptimizeChunkModules: 'after chunk modules optimization',\n        reviveModules: 'module reviving',\n        beforeModuleIds: 'before module ids',\n        moduleIds: 'module ids',\n        optimizeModuleIds: 'module id optimization',\n        afterOptimizeModuleIds: 'module id optimization',\n        reviveChunks: 'chunk reviving',\n        beforeChunkIds: 'before chunk ids',\n        chunkIds: 'chunk ids',\n        optimizeChunkIds: 'chunk id optimization',\n        afterOptimizeChunkIds: 'after chunk id optimization',\n        recordModules: 'record modules',\n        recordChunks: 'record chunks',\n        beforeModuleHash: 'module hashing',\n        beforeCodeGeneration: 'code generation',\n        beforeRuntimeRequirements: 'runtime requirements',\n        beforeHash: 'hashing',\n        afterHash: 'after hashing',\n        recordHash: 'record hash',\n        beforeModuleAssets: 'module assets processing',\n        beforeChunkAssets: 'chunk assets processing',\n        processAssets: 'asset processing',\n        afterProcessAssets: 'after asset optimization',\n        record: 'recording',\n        afterSeal: 'after seal',\n      };\n      const numberOfHooks = Object.keys(hooks).length;\n      Object.keys(hooks).forEach((name, idx) => {\n        const title = hooks[name];\n        const percentage = (idx / numberOfHooks) * 0.25 + 0.7;\n        compilation.hooks[name].intercept({\n          name: 'ProgressPlugin',\n          call() {\n            handler(percentage, 'sealing', title);\n          },\n          done() {\n            progressReporters.set(compiler, undefined);\n            handler(percentage, 'sealing', title);\n          },\n          result() {\n            handler(percentage, 'sealing', title);\n          },\n          error() {\n            handler(percentage, 'sealing', title);\n          },\n          tap(tap) {\n            // p is percentage from 0 to 1\n            // args is any number of messages in a hierarchical matter\n            progressReporters.set(compilation.compiler, (p, ...args) => {\n              handler(percentage, 'sealing', title, tap.name, ...args);\n            });\n            handler(percentage, 'sealing', title, tap.name);\n          },\n        });\n      });\n    });\n    compiler.hooks.make.intercept({\n      name: 'ProgressPlugin',\n      call() {\n        handler(0.1, 'building');\n      },\n      done() {\n        handler(0.65, 'building');\n      },\n    });\n    const interceptHook = (hook, progress, category, name) => {\n      hook.intercept({\n        name: 'ProgressPlugin',\n        call() {\n          handler(progress, category, name);\n        },\n        done() {\n          progressReporters.set(compiler, undefined);\n          handler(progress, category, name);\n        },\n        result() {\n          handler(progress, category, name);\n        },\n        error() {\n          handler(progress, category, name);\n        },\n        tap(tap) {\n          progressReporters.set(compiler, (p, ...args) => {\n            handler(progress, category, name, tap.name, ...args);\n          });\n          handler(progress, category, name, tap.name);\n        },\n      });\n    };\n    compiler.cache.hooks.endIdle.intercept({\n      name: 'ProgressPlugin',\n      call() {\n        handler(0, '');\n      },\n    });\n    interceptHook(compiler.cache.hooks.endIdle, 0.01, 'cache', 'end idle');\n    compiler.hooks.beforeRun.intercept({\n      name: 'ProgressPlugin',\n      call() {\n        handler(0, '');\n      },\n    });\n    interceptHook(compiler.hooks.beforeRun, 0.01, 'setup', 'before run');\n    interceptHook(compiler.hooks.run, 0.02, 'setup', 'run');\n    interceptHook(compiler.hooks.watchRun, 0.03, 'setup', 'watch run');\n    interceptHook(compiler.hooks.normalModuleFactory, 0.04, 'setup', 'normal module factory');\n    interceptHook(compiler.hooks.contextModuleFactory, 0.05, 'setup', 'context module factory');\n    interceptHook(compiler.hooks.beforeCompile, 0.06, 'setup', 'before compile');\n    interceptHook(compiler.hooks.compile, 0.07, 'setup', 'compile');\n    interceptHook(compiler.hooks.thisCompilation, 0.08, 'setup', 'compilation');\n    interceptHook(compiler.hooks.compilation, 0.09, 'setup', 'compilation');\n    interceptHook(compiler.hooks.finishMake, 0.69, 'building', 'finish');\n    interceptHook(compiler.hooks.emit, 0.95, 'emitting', 'emit');\n    interceptHook(compiler.hooks.afterEmit, 0.98, 'emitting', 'after emit');\n    interceptHook(compiler.hooks.done, 0.99, 'done', 'plugins');\n    compiler.hooks.done.intercept({\n      name: 'ProgressPlugin',\n      done() {\n        handler(0.99, '');\n      },\n    });\n    interceptHook(\n      compiler.cache.hooks.storeBuildDependencies,\n      0.99,\n      'cache',\n      'store build dependencies',\n    );\n    interceptHook(compiler.cache.hooks.shutdown, 0.99, 'cache', 'shutdown');\n    interceptHook(compiler.cache.hooks.beginIdle, 0.99, 'cache', 'begin idle');\n    interceptHook(compiler.hooks.watchClose, 0.99, 'end', 'closing watch compilation');\n    compiler.cache.hooks.beginIdle.intercept({\n      name: 'ProgressPlugin',\n      done() {\n        handler(1, '');\n      },\n    });\n    compiler.cache.hooks.shutdown.intercept({\n      name: 'ProgressPlugin',\n      done() {\n        handler(1, '');\n      },\n    });\n  }\n}\n\nProgressPlugin.defaultOptions = {\n  profile: false,\n  modulesCount: 5000,\n  dependenciesCount: 10000,\n  modules: true,\n  dependencies: true,\n  activeModules: false,\n  entries: true,\n};\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-rspack/schema.d.ts b/artifacts/build-angular/src/builders/browser-rspack/schema.d.ts new file mode 100644 index 00000000..44729a7b --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-rspack/schema.d.ts @@ -0,0 +1,428 @@ +/** + * Browser target options + */ +export interface Schema { + /** + * A list of CommonJS packages that are allowed to be used without a build time warning. + */ + allowedCommonJsDependencies?: string[]; + /** + * Build using Ahead of Time compilation. + */ + aot?: boolean; + /** + * List of static application assets. + */ + assets?: AssetPattern[]; + /** + * Base url for the application being built. + */ + baseHref?: string; + /** + * Budget thresholds to ensure parts of your application stay within boundaries which you + * set. + */ + budgets?: Budget[]; + /** + * Enables advanced build optimizations when using the 'aot' option. + */ + buildOptimizer?: boolean; + /** + * Generate a seperate bundle containing code used across multiple bundles. + */ + commonChunk?: boolean; + /** + * Define the crossorigin attribute setting of elements that provide CORS support. + */ + crossOrigin?: CrossOrigin; + /** + * Delete the output path before building. + */ + deleteOutputPath?: boolean; + /** + * URL where files will be deployed. + * @deprecated Use "baseHref" option, "APP_BASE_HREF" DI token or a combination of both + * instead. For more information, see https://angular.io/guide/deployment#the-deploy-url. + */ + deployUrl?: string; + /** + * Extract all licenses in a separate file. + */ + extractLicenses?: boolean; + /** + * Replace compilation source files with other compilation source files in the build. + */ + fileReplacements?: FileReplacement[]; + /** + * How to handle duplicate translations for i18n. + */ + i18nDuplicateTranslation?: I18NTranslation; + /** + * How to handle missing translations for i18n. + */ + i18nMissingTranslation?: I18NTranslation; + /** + * Configures the generation of the application's HTML index. + */ + index: IndexUnion; + /** + * The stylesheet language to use for the application's inline component styles. + */ + inlineStyleLanguage?: InlineStyleLanguage; + /** + * Translate the bundles in one or more locales. + */ + localize?: Localize; + /** + * The full path for the main entry point to the app, relative to the current workspace. + */ + main: string; + /** + * Use file name for lazy loaded chunks. + */ + namedChunks?: boolean; + /** + * Path to ngsw-config.json. + */ + ngswConfigPath?: string; + /** + * Enables optimization of the build output. Including minification of scripts and styles, + * tree-shaking, dead-code elimination, inlining of critical CSS and fonts inlining. For + * more information, see + * https://angular.io/guide/workspace-config#optimization-configuration. + */ + optimization?: OptimizationUnion; + /** + * Define the output filename cache-busting hashing mode. + */ + outputHashing?: OutputHashing; + /** + * The full path for the new output directory, relative to the current workspace. + * By default, writes output to a folder named dist/ in the current project. + */ + outputPath: string; + /** + * Enable and define the file watching poll time period in milliseconds. + */ + poll?: number; + /** + * Polyfills to be included in the build. + */ + polyfills?: Polyfills; + /** + * Do not use the real path when resolving modules. If unset then will default to `true` if + * NodeJS option --preserve-symlinks is set. + */ + preserveSymlinks?: boolean; + /** + * Log progress to the console while building. + */ + progress?: boolean; + /** + * The path where style resources will be placed, relative to outputPath. + */ + resourcesOutputPath?: string; + /** + * Global scripts to be included in the build. + */ + scripts?: ScriptElement[]; + /** + * Generates a service worker config for production builds. + */ + serviceWorker?: boolean; + /** + * Output source maps for scripts and styles. For more information, see + * https://angular.io/guide/workspace-config#source-map-configuration. + */ + sourceMap?: SourceMapUnion; + /** + * Generates a 'stats.json' file which can be analyzed using tools such as + * 'webpack-bundle-analyzer'. + */ + statsJson?: boolean; + /** + * Options to pass to style preprocessors. + */ + stylePreprocessorOptions?: StylePreprocessorOptions; + /** + * Global styles to be included in the build. + */ + styles?: StyleElement[]; + /** + * Enables the use of subresource integrity validation. + */ + subresourceIntegrity?: boolean; + /** + * The full path for the TypeScript configuration file, relative to the current workspace. + */ + tsConfig: string; + /** + * Generate a seperate bundle containing only vendor libraries. This option should only be + * used for development to reduce the incremental compilation time. + */ + vendorChunk?: boolean; + /** + * Adds more details to output logging. + */ + verbose?: boolean; + /** + * Run build when files change. + */ + watch?: boolean; + /** + * TypeScript configuration for Web Worker modules. + */ + webWorkerTsConfig?: string; +} +export 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 Budget { + /** + * The baseline size for comparison. + */ + baseline?: string; + /** + * The threshold for error relative to the baseline (min & max). + */ + error?: string; + /** + * The maximum threshold for error relative to the baseline. + */ + maximumError?: string; + /** + * The maximum threshold for warning relative to the baseline. + */ + maximumWarning?: string; + /** + * The minimum threshold for error relative to the baseline. + */ + minimumError?: string; + /** + * The minimum threshold for warning relative to the baseline. + */ + minimumWarning?: string; + /** + * The name of the bundle. + */ + name?: string; + /** + * The type of budget. + */ + type: Type; + /** + * The threshold for warning relative to the baseline (min & max). + */ + warning?: string; +} +/** + * The type of budget. + */ +export declare enum Type { + All = "all", + AllScript = "allScript", + Any = "any", + AnyComponentStyle = "anyComponentStyle", + AnyScript = "anyScript", + Bundle = "bundle", + Initial = "initial" +} +/** + * Define the crossorigin attribute setting of elements that provide CORS support. + */ +export declare enum CrossOrigin { + Anonymous = "anonymous", + None = "none", + UseCredentials = "use-credentials" +} +export interface FileReplacement { + replace?: string; + replaceWith?: string; + src?: string; + with?: string; +} +/** + * How to handle duplicate translations for i18n. + * + * How to handle missing translations for i18n. + */ +export declare enum I18NTranslation { + Error = "error", + Ignore = "ignore", + Warning = "warning" +} +/** + * Configures the generation of the application's HTML index. + */ +export type IndexUnion = IndexObject | string; +export interface IndexObject { + /** + * The path of a file to use for the application's generated HTML index. + */ + input: string; + /** + * The output path of the application's generated HTML index file. The full provided path + * will be used and will be considered relative to the application's configured output path. + */ + output?: string; + [property: string]: any; +} +/** + * The stylesheet language to use for the application's inline component styles. + */ +export declare enum InlineStyleLanguage { + Css = "css", + Less = "less", + Sass = "sass", + Scss = "scss" +} +/** + * Translate the bundles in one or more locales. + */ +export type Localize = string[] | boolean; +/** + * Enables optimization of the build output. Including minification of scripts and styles, + * tree-shaking, dead-code elimination, inlining of critical CSS and fonts inlining. For + * more information, see + * https://angular.io/guide/workspace-config#optimization-configuration. + */ +export type OptimizationUnion = boolean | OptimizationClass; +export interface OptimizationClass { + /** + * Enables optimization for fonts. This option requires internet access. `HTTPS_PROXY` + * environment variable can be used to specify a proxy server. + */ + fonts?: FontsUnion; + /** + * Enables optimization of the scripts output. + */ + scripts?: boolean; + /** + * Enables optimization of the styles output. + */ + styles?: StylesUnion; +} +/** + * Enables optimization for fonts. This option requires internet access. `HTTPS_PROXY` + * environment variable can be used to specify a proxy server. + */ +export type FontsUnion = boolean | FontsClass; +export interface FontsClass { + /** + * Reduce render blocking requests by inlining external Google Fonts and Adobe Fonts CSS + * definitions in the application's HTML index file. This option requires internet access. + * `HTTPS_PROXY` environment variable can be used to specify a proxy server. + */ + inline?: boolean; +} +/** + * Enables optimization of the styles output. + */ +export type StylesUnion = boolean | StylesClass; +export interface StylesClass { + /** + * Extract and inline critical CSS definitions to improve first paint time. + */ + inlineCritical?: boolean; + /** + * Minify CSS definitions by removing extraneous whitespace and comments, merging + * identifiers and minimizing values. + */ + minify?: boolean; +} +/** + * Define the output filename cache-busting hashing mode. + */ +export declare enum OutputHashing { + All = "all", + Bundles = "bundles", + Media = "media", + None = "none" +} +/** + * Polyfills to be included in the build. + */ +export type Polyfills = string[] | string; +export type ScriptElement = ScriptClass | string; +export interface ScriptClass { + /** + * The bundle name for this extra entry point. + */ + bundleName?: string; + /** + * If the bundle will be referenced in the HTML file. + */ + inject?: boolean; + /** + * The file to include. + */ + input: string; +} +/** + * Output source maps for scripts and styles. For more information, see + * https://angular.io/guide/workspace-config#source-map-configuration. + */ +export type SourceMapUnion = boolean | SourceMapClass; +export interface SourceMapClass { + /** + * Output source maps used for error reporting tools. + */ + hidden?: boolean; + /** + * Output source maps for all scripts. + */ + scripts?: boolean; + /** + * Output source maps for all styles. + */ + styles?: boolean; + /** + * Resolve vendor packages source maps. + */ + vendor?: boolean; +} +/** + * Options to pass to style preprocessors. + */ +export interface StylePreprocessorOptions { + /** + * Paths to include. Paths will be resolved to workspace root. + */ + includePaths?: string[]; +} +export type StyleElement = StyleClass | string; +export interface StyleClass { + /** + * The bundle name for this extra entry point. + */ + bundleName?: string; + /** + * If the bundle will be referenced in the HTML file. + */ + inject?: boolean; + /** + * The file to include. + */ + input: string; +} diff --git a/artifacts/build-angular/src/builders/browser-rspack/schema.js b/artifacts/build-angular/src/builders/browser-rspack/schema.js new file mode 100644 index 00000000..c97ea24b --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-rspack/schema.js @@ -0,0 +1,59 @@ +"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 }); +exports.OutputHashing = exports.InlineStyleLanguage = exports.I18NTranslation = exports.CrossOrigin = exports.Type = void 0; +/** + * The type of budget. + */ +var Type; +(function (Type) { + Type["All"] = "all"; + Type["AllScript"] = "allScript"; + Type["Any"] = "any"; + Type["AnyComponentStyle"] = "anyComponentStyle"; + Type["AnyScript"] = "anyScript"; + Type["Bundle"] = "bundle"; + Type["Initial"] = "initial"; +})(Type = exports.Type || (exports.Type = {})); +/** + * Define the crossorigin attribute setting of elements that provide CORS support. + */ +var CrossOrigin; +(function (CrossOrigin) { + CrossOrigin["Anonymous"] = "anonymous"; + CrossOrigin["None"] = "none"; + CrossOrigin["UseCredentials"] = "use-credentials"; +})(CrossOrigin = exports.CrossOrigin || (exports.CrossOrigin = {})); +/** + * How to handle duplicate translations for i18n. + * + * How to handle missing translations for i18n. + */ +var I18NTranslation; +(function (I18NTranslation) { + I18NTranslation["Error"] = "error"; + I18NTranslation["Ignore"] = "ignore"; + I18NTranslation["Warning"] = "warning"; +})(I18NTranslation = exports.I18NTranslation || (exports.I18NTranslation = {})); +/** + * The stylesheet language to use for the application's inline component styles. + */ +var InlineStyleLanguage; +(function (InlineStyleLanguage) { + InlineStyleLanguage["Css"] = "css"; + InlineStyleLanguage["Less"] = "less"; + InlineStyleLanguage["Sass"] = "sass"; + InlineStyleLanguage["Scss"] = "scss"; +})(InlineStyleLanguage = exports.InlineStyleLanguage || (exports.InlineStyleLanguage = {})); +/** + * Define the output filename cache-busting hashing mode. + */ +var OutputHashing; +(function (OutputHashing) { + OutputHashing["All"] = "all"; + OutputHashing["Bundles"] = "bundles"; + OutputHashing["Media"] = "media"; + OutputHashing["None"] = "none"; +})(OutputHashing = exports.OutputHashing || (exports.OutputHashing = {})); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-rspack/schema.ts"],"names":[],"mappings":";AACA,mFAAmF;AACnF,oFAAoF;;;AAoPpF;;GAEG;AACH,IAAY,IAQX;AARD,WAAY,IAAI;IACZ,mBAAW,CAAA;IACX,+BAAuB,CAAA;IACvB,mBAAW,CAAA;IACX,+CAAuC,CAAA;IACvC,+BAAuB,CAAA;IACvB,yBAAiB,CAAA;IACjB,2BAAmB,CAAA;AACvB,CAAC,EARW,IAAI,GAAJ,YAAI,KAAJ,YAAI,QAQf;AAED;;GAEG;AACH,IAAY,WAIX;AAJD,WAAY,WAAW;IACnB,sCAAuB,CAAA;IACvB,4BAAa,CAAA;IACb,iDAAkC,CAAA;AACtC,CAAC,EAJW,WAAW,GAAX,mBAAW,KAAX,mBAAW,QAItB;AASD;;;;GAIG;AACH,IAAY,eAIX;AAJD,WAAY,eAAe;IACvB,kCAAe,CAAA;IACf,oCAAiB,CAAA;IACjB,sCAAmB,CAAA;AACvB,CAAC,EAJW,eAAe,GAAf,uBAAe,KAAf,uBAAe,QAI1B;AAoBD;;GAEG;AACH,IAAY,mBAKX;AALD,WAAY,mBAAmB;IAC3B,kCAAW,CAAA;IACX,oCAAa,CAAA;IACb,oCAAa,CAAA;IACb,oCAAa,CAAA;AACjB,CAAC,EALW,mBAAmB,GAAnB,2BAAmB,KAAnB,2BAAmB,QAK9B;AA+DD;;GAEG;AACH,IAAY,aAKX;AALD,WAAY,aAAa;IACrB,4BAAW,CAAA;IACX,oCAAmB,CAAA;IACnB,gCAAe,CAAA;IACf,8BAAa,CAAA;AACjB,CAAC,EALW,aAAa,GAAb,qBAAa,KAAb,qBAAa,QAKxB","sourcesContent":["\n// THIS FILE IS AUTOMATICALLY GENERATED. TO UPDATE THIS FILE YOU NEED TO CHANGE THE\n// CORRESPONDING JSON SCHEMA FILE, THEN RUN devkit-admin build (or bazel build ...).\n\n/**\n * Browser target options\n */\nexport interface Schema {\n    /**\n     * A list of CommonJS packages that are allowed to be used without a build time warning.\n     */\n    allowedCommonJsDependencies?: string[];\n    /**\n     * Build using Ahead of Time compilation.\n     */\n    aot?: boolean;\n    /**\n     * List of static application assets.\n     */\n    assets?: AssetPattern[];\n    /**\n     * Base url for the application being built.\n     */\n    baseHref?: string;\n    /**\n     * Budget thresholds to ensure parts of your application stay within boundaries which you\n     * set.\n     */\n    budgets?: Budget[];\n    /**\n     * Enables advanced build optimizations when using the 'aot' option.\n     */\n    buildOptimizer?: boolean;\n    /**\n     * Generate a seperate bundle containing code used across multiple bundles.\n     */\n    commonChunk?: boolean;\n    /**\n     * Define the crossorigin attribute setting of elements that provide CORS support.\n     */\n    crossOrigin?: CrossOrigin;\n    /**\n     * Delete the output path before building.\n     */\n    deleteOutputPath?: boolean;\n    /**\n     * URL where files will be deployed.\n     * @deprecated Use \"baseHref\" option, \"APP_BASE_HREF\" DI token or a combination of both\n     * instead. For more information, see https://angular.io/guide/deployment#the-deploy-url.\n     */\n    deployUrl?: string;\n    /**\n     * Extract all licenses in a separate file.\n     */\n    extractLicenses?: boolean;\n    /**\n     * Replace compilation source files with other compilation source files in the build.\n     */\n    fileReplacements?: FileReplacement[];\n    /**\n     * How to handle duplicate translations for i18n.\n     */\n    i18nDuplicateTranslation?: I18NTranslation;\n    /**\n     * How to handle missing translations for i18n.\n     */\n    i18nMissingTranslation?: I18NTranslation;\n    /**\n     * Configures the generation of the application's HTML index.\n     */\n    index: IndexUnion;\n    /**\n     * The stylesheet language to use for the application's inline component styles.\n     */\n    inlineStyleLanguage?: InlineStyleLanguage;\n    /**\n     * Translate the bundles in one or more locales.\n     */\n    localize?: Localize;\n    /**\n     * The full path for the main entry point to the app, relative to the current workspace.\n     */\n    main: string;\n    /**\n     * Use file name for lazy loaded chunks.\n     */\n    namedChunks?: boolean;\n    /**\n     * Path to ngsw-config.json.\n     */\n    ngswConfigPath?: string;\n    /**\n     * Enables optimization of the build output. Including minification of scripts and styles,\n     * tree-shaking, dead-code elimination, inlining of critical CSS and fonts inlining. For\n     * more information, see\n     * https://angular.io/guide/workspace-config#optimization-configuration.\n     */\n    optimization?: OptimizationUnion;\n    /**\n     * Define the output filename cache-busting hashing mode.\n     */\n    outputHashing?: OutputHashing;\n    /**\n     * The full path for the new output directory, relative to the current workspace.\n     * By default, writes output to a folder named dist/ in the current project.\n     */\n    outputPath: string;\n    /**\n     * Enable and define the file watching poll time period in milliseconds.\n     */\n    poll?: number;\n    /**\n     * Polyfills to be included in the build.\n     */\n    polyfills?: Polyfills;\n    /**\n     * Do not use the real path when resolving modules. If unset then will default to `true` if\n     * NodeJS option --preserve-symlinks is set.\n     */\n    preserveSymlinks?: boolean;\n    /**\n     * Log progress to the console while building.\n     */\n    progress?: boolean;\n    /**\n     * The path where style resources will be placed, relative to outputPath.\n     */\n    resourcesOutputPath?: string;\n    /**\n     * Global scripts to be included in the build.\n     */\n    scripts?: ScriptElement[];\n    /**\n     * Generates a service worker config for production builds.\n     */\n    serviceWorker?: boolean;\n    /**\n     * Output source maps for scripts and styles. For more information, see\n     * https://angular.io/guide/workspace-config#source-map-configuration.\n     */\n    sourceMap?: SourceMapUnion;\n    /**\n     * Generates a 'stats.json' file which can be analyzed using tools such as\n     * 'webpack-bundle-analyzer'.\n     */\n    statsJson?: boolean;\n    /**\n     * Options to pass to style preprocessors.\n     */\n    stylePreprocessorOptions?: StylePreprocessorOptions;\n    /**\n     * Global styles to be included in the build.\n     */\n    styles?: StyleElement[];\n    /**\n     * Enables the use of subresource integrity validation.\n     */\n    subresourceIntegrity?: boolean;\n    /**\n     * The full path for the TypeScript configuration file, relative to the current workspace.\n     */\n    tsConfig: string;\n    /**\n     * Generate a seperate bundle containing only vendor libraries. This option should only be\n     * used for development to reduce the incremental compilation time.\n     */\n    vendorChunk?: boolean;\n    /**\n     * Adds more details to output logging.\n     */\n    verbose?: boolean;\n    /**\n     * Run build when files change.\n     */\n    watch?: boolean;\n    /**\n     * TypeScript configuration for Web Worker modules.\n     */\n    webWorkerTsConfig?: string;\n}\n\nexport type AssetPattern = AssetPatternClass | string;\n\nexport interface AssetPatternClass {\n    /**\n     * Allow glob patterns to follow symlink directories. This allows subdirectories of the\n     * symlink to be searched.\n     */\n    followSymlinks?: boolean;\n    /**\n     * The pattern to match.\n     */\n    glob: string;\n    /**\n     * An array of globs to ignore.\n     */\n    ignore?: string[];\n    /**\n     * The input directory path in which to apply 'glob'. Defaults to the project root.\n     */\n    input: string;\n    /**\n     * Absolute path within the output.\n     */\n    output: string;\n}\n\nexport interface Budget {\n    /**\n     * The baseline size for comparison.\n     */\n    baseline?: string;\n    /**\n     * The threshold for error relative to the baseline (min & max).\n     */\n    error?: string;\n    /**\n     * The maximum threshold for error relative to the baseline.\n     */\n    maximumError?: string;\n    /**\n     * The maximum threshold for warning relative to the baseline.\n     */\n    maximumWarning?: string;\n    /**\n     * The minimum threshold for error relative to the baseline.\n     */\n    minimumError?: string;\n    /**\n     * The minimum threshold for warning relative to the baseline.\n     */\n    minimumWarning?: string;\n    /**\n     * The name of the bundle.\n     */\n    name?: string;\n    /**\n     * The type of budget.\n     */\n    type: Type;\n    /**\n     * The threshold for warning relative to the baseline (min & max).\n     */\n    warning?: string;\n}\n\n/**\n * The type of budget.\n */\nexport enum Type {\n    All = \"all\",\n    AllScript = \"allScript\",\n    Any = \"any\",\n    AnyComponentStyle = \"anyComponentStyle\",\n    AnyScript = \"anyScript\",\n    Bundle = \"bundle\",\n    Initial = \"initial\",\n}\n\n/**\n * Define the crossorigin attribute setting of elements that provide CORS support.\n */\nexport enum CrossOrigin {\n    Anonymous = \"anonymous\",\n    None = \"none\",\n    UseCredentials = \"use-credentials\",\n}\n\nexport interface FileReplacement {\n    replace?:     string;\n    replaceWith?: string;\n    src?:         string;\n    with?:        string;\n}\n\n/**\n * How to handle duplicate translations for i18n.\n *\n * How to handle missing translations for i18n.\n */\nexport enum I18NTranslation {\n    Error = \"error\",\n    Ignore = \"ignore\",\n    Warning = \"warning\",\n}\n\n/**\n * Configures the generation of the application's HTML index.\n */\nexport type IndexUnion = IndexObject | string;\n\nexport interface IndexObject {\n    /**\n     * The path of a file to use for the application's generated HTML index.\n     */\n    input: string;\n    /**\n     * The output path of the application's generated HTML index file. The full provided path\n     * will be used and will be considered relative to the application's configured output path.\n     */\n    output?: string;\n    [property: string]: any;\n}\n\n/**\n * The stylesheet language to use for the application's inline component styles.\n */\nexport enum InlineStyleLanguage {\n    Css = \"css\",\n    Less = \"less\",\n    Sass = \"sass\",\n    Scss = \"scss\",\n}\n\n/**\n * Translate the bundles in one or more locales.\n */\nexport type Localize = string[] | boolean;\n\n/**\n * Enables optimization of the build output. Including minification of scripts and styles,\n * tree-shaking, dead-code elimination, inlining of critical CSS and fonts inlining. For\n * more information, see\n * https://angular.io/guide/workspace-config#optimization-configuration.\n */\nexport type OptimizationUnion = boolean | OptimizationClass;\n\nexport interface OptimizationClass {\n    /**\n     * Enables optimization for fonts. This option requires internet access. `HTTPS_PROXY`\n     * environment variable can be used to specify a proxy server.\n     */\n    fonts?: FontsUnion;\n    /**\n     * Enables optimization of the scripts output.\n     */\n    scripts?: boolean;\n    /**\n     * Enables optimization of the styles output.\n     */\n    styles?: StylesUnion;\n}\n\n/**\n * Enables optimization for fonts. This option requires internet access. `HTTPS_PROXY`\n * environment variable can be used to specify a proxy server.\n */\nexport type FontsUnion = boolean | FontsClass;\n\nexport interface FontsClass {\n    /**\n     * Reduce render blocking requests by inlining external Google Fonts and Adobe Fonts CSS\n     * definitions in the application's HTML index file. This option requires internet access.\n     * `HTTPS_PROXY` environment variable can be used to specify a proxy server.\n     */\n    inline?: boolean;\n}\n\n/**\n * Enables optimization of the styles output.\n */\nexport type StylesUnion = boolean | StylesClass;\n\nexport interface StylesClass {\n    /**\n     * Extract and inline critical CSS definitions to improve first paint time.\n     */\n    inlineCritical?: boolean;\n    /**\n     * Minify CSS definitions by removing extraneous whitespace and comments, merging\n     * identifiers and minimizing values.\n     */\n    minify?: boolean;\n}\n\n/**\n * Define the output filename cache-busting hashing mode.\n */\nexport enum OutputHashing {\n    All = \"all\",\n    Bundles = \"bundles\",\n    Media = \"media\",\n    None = \"none\",\n}\n\n/**\n * Polyfills to be included in the build.\n */\nexport type Polyfills = string[] | string;\n\nexport type ScriptElement = ScriptClass | string;\n\nexport interface ScriptClass {\n    /**\n     * The bundle name for this extra entry point.\n     */\n    bundleName?: string;\n    /**\n     * If the bundle will be referenced in the HTML file.\n     */\n    inject?: boolean;\n    /**\n     * The file to include.\n     */\n    input: string;\n}\n\n/**\n * Output source maps for scripts and styles. For more information, see\n * https://angular.io/guide/workspace-config#source-map-configuration.\n */\nexport type SourceMapUnion = boolean | SourceMapClass;\n\nexport interface SourceMapClass {\n    /**\n     * Output source maps used for error reporting tools.\n     */\n    hidden?: boolean;\n    /**\n     * Output source maps for all scripts.\n     */\n    scripts?: boolean;\n    /**\n     * Output source maps for all styles.\n     */\n    styles?: boolean;\n    /**\n     * Resolve vendor packages source maps.\n     */\n    vendor?: boolean;\n}\n\n/**\n * Options to pass to style preprocessors.\n */\nexport interface StylePreprocessorOptions {\n    /**\n     * Paths to include. Paths will be resolved to workspace root.\n     */\n    includePaths?: string[];\n}\n\nexport type StyleElement = StyleClass | string;\n\nexport interface StyleClass {\n    /**\n     * The bundle name for this extra entry point.\n     */\n    bundleName?: string;\n    /**\n     * If the bundle will be referenced in the HTML file.\n     */\n    inject?: boolean;\n    /**\n     * The file to include.\n     */\n    input: string;\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser-rspack/schema.json b/artifacts/build-angular/src/builders/browser-rspack/schema.json new file mode 100644 index 00000000..b45065bb --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-rspack/schema.json @@ -0,0 +1,548 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema", + "title": "Webpack browser schema for Build Facade.", + "description": "Browser target options", + "type": "object", + "properties": { + "assets": { + "type": "array", + "description": "List of static application assets.", + "default": [], + "items": { + "$ref": "#/definitions/assetPattern" + } + }, + "main": { + "type": "string", + "description": "The full path for the main entry point to the app, relative to the current workspace." + }, + "polyfills": { + "description": "Polyfills to be included in the build.", + "oneOf": [ + { + "type": "array", + "description": "A list of polyfills to include in the build. Can be a full path for a file, relative to the current workspace or module specifier. Example: 'zone.js'.", + "items": { + "type": "string", + "uniqueItems": true + }, + "default": [] + }, + { + "type": "string", + "description": "The full path for the polyfills file, relative to the current workspace or a module specifier. Example: 'zone.js'." + } + ] + }, + "tsConfig": { + "type": "string", + "description": "The full path for the TypeScript configuration file, relative to the current workspace." + }, + "scripts": { + "description": "Global scripts to be included in the build.", + "type": "array", + "default": [], + "items": { + "oneOf": [ + { + "type": "object", + "properties": { + "input": { + "type": "string", + "description": "The file to include.", + "pattern": "\\.[cm]?jsx?$" + }, + "bundleName": { + "type": "string", + "pattern": "^[\\w\\-.]*$", + "description": "The bundle name for this extra entry point." + }, + "inject": { + "type": "boolean", + "description": "If the bundle will be referenced in the HTML file.", + "default": true + } + }, + "additionalProperties": false, + "required": ["input"] + }, + { + "type": "string", + "description": "The file to include.", + "pattern": "\\.[cm]?jsx?$" + } + ] + } + }, + "styles": { + "description": "Global styles to be included in the build.", + "type": "array", + "default": [], + "items": { + "oneOf": [ + { + "type": "object", + "properties": { + "input": { + "type": "string", + "description": "The file to include.", + "pattern": "\\.(?:css|scss|sass|less)$" + }, + "bundleName": { + "type": "string", + "pattern": "^[\\w\\-.]*$", + "description": "The bundle name for this extra entry point." + }, + "inject": { + "type": "boolean", + "description": "If the bundle will be referenced in the HTML file.", + "default": true + } + }, + "additionalProperties": false, + "required": ["input"] + }, + { + "type": "string", + "description": "The file to include.", + "pattern": "\\.(?:css|scss|sass|less)$" + } + ] + } + }, + "inlineStyleLanguage": { + "description": "The stylesheet language to use for the application's inline component styles.", + "type": "string", + "default": "css", + "enum": ["css", "less", "sass", "scss"] + }, + "stylePreprocessorOptions": { + "description": "Options to pass to style preprocessors.", + "type": "object", + "properties": { + "includePaths": { + "description": "Paths to include. Paths will be resolved to workspace root.", + "type": "array", + "items": { + "type": "string" + }, + "default": [] + } + }, + "additionalProperties": false + }, + "optimization": { + "description": "Enables optimization of the build output. Including minification of scripts and styles, tree-shaking, dead-code elimination, inlining of critical CSS and fonts inlining. For more information, see https://angular.io/guide/workspace-config#optimization-configuration.", + "default": true, + "x-user-analytics": "ep.ng_optimization", + "oneOf": [ + { + "type": "object", + "properties": { + "scripts": { + "type": "boolean", + "description": "Enables optimization of the scripts output.", + "default": true + }, + "styles": { + "description": "Enables optimization of the styles output.", + "default": true, + "oneOf": [ + { + "type": "object", + "properties": { + "minify": { + "type": "boolean", + "description": "Minify CSS definitions by removing extraneous whitespace and comments, merging identifiers and minimizing values.", + "default": true + }, + "inlineCritical": { + "type": "boolean", + "description": "Extract and inline critical CSS definitions to improve first paint time.", + "default": true + } + }, + "additionalProperties": false + }, + { + "type": "boolean" + } + ] + }, + "fonts": { + "description": "Enables optimization for fonts. This option requires internet access. `HTTPS_PROXY` environment variable can be used to specify a proxy server.", + "default": true, + "oneOf": [ + { + "type": "object", + "properties": { + "inline": { + "type": "boolean", + "description": "Reduce render blocking requests by inlining external Google Fonts and Adobe Fonts CSS definitions in the application's HTML index file. This option requires internet access. `HTTPS_PROXY` environment variable can be used to specify a proxy server.", + "default": true + } + }, + "additionalProperties": false + }, + { + "type": "boolean" + } + ] + } + }, + "additionalProperties": false + }, + { + "type": "boolean" + } + ] + }, + "fileReplacements": { + "description": "Replace compilation source files with other compilation source files in the build.", + "type": "array", + "items": { + "$ref": "#/definitions/fileReplacement" + }, + "default": [] + }, + "outputPath": { + "type": "string", + "description": "The full path for the new output directory, relative to the current workspace.\nBy default, writes output to a folder named dist/ in the current project." + }, + "resourcesOutputPath": { + "type": "string", + "description": "The path where style resources will be placed, relative to outputPath." + }, + "aot": { + "type": "boolean", + "description": "Build using Ahead of Time compilation.", + "x-user-analytics": "ep.ng_aot", + "default": true + }, + "sourceMap": { + "description": "Output source maps for scripts and styles. For more information, see https://angular.io/guide/workspace-config#source-map-configuration.", + "default": false, + "oneOf": [ + { + "type": "object", + "properties": { + "scripts": { + "type": "boolean", + "description": "Output source maps for all scripts.", + "default": true + }, + "styles": { + "type": "boolean", + "description": "Output source maps for all styles.", + "default": true + }, + "hidden": { + "type": "boolean", + "description": "Output source maps used for error reporting tools.", + "default": false + }, + "vendor": { + "type": "boolean", + "description": "Resolve vendor packages source maps.", + "default": false + } + }, + "additionalProperties": false + }, + { + "type": "boolean" + } + ] + }, + "vendorChunk": { + "type": "boolean", + "description": "Generate a seperate bundle containing only vendor libraries. This option should only be used for development to reduce the incremental compilation time.", + "default": false + }, + "commonChunk": { + "type": "boolean", + "description": "Generate a seperate bundle containing code used across multiple bundles.", + "default": true + }, + "baseHref": { + "type": "string", + "description": "Base url for the application being built." + }, + "deployUrl": { + "type": "string", + "description": "URL where files will be deployed.", + "x-deprecated": "Use \"baseHref\" option, \"APP_BASE_HREF\" DI token or a combination of both instead. For more information, see https://angular.io/guide/deployment#the-deploy-url." + }, + "verbose": { + "type": "boolean", + "description": "Adds more details to output logging.", + "default": false + }, + "progress": { + "type": "boolean", + "description": "Log progress to the console while building.", + "default": true + }, + "i18nMissingTranslation": { + "type": "string", + "description": "How to handle missing translations for i18n.", + "enum": ["warning", "error", "ignore"], + "default": "warning" + }, + "i18nDuplicateTranslation": { + "type": "string", + "description": "How to handle duplicate translations for i18n.", + "enum": ["warning", "error", "ignore"], + "default": "warning" + }, + "localize": { + "description": "Translate the bundles in one or more locales.", + "oneOf": [ + { + "type": "boolean", + "description": "Translate all locales." + }, + { + "type": "array", + "description": "List of locales ID's to translate.", + "minItems": 1, + "items": { + "type": "string", + "pattern": "^[a-zA-Z]{2,3}(-[a-zA-Z]{4})?(-([a-zA-Z]{2}|[0-9]{3}))?(-[a-zA-Z]{5,8})?(-x(-[a-zA-Z0-9]{1,8})+)?$" + } + } + ] + }, + "watch": { + "type": "boolean", + "description": "Run build when files change.", + "default": false + }, + "outputHashing": { + "type": "string", + "description": "Define the output filename cache-busting hashing mode.", + "default": "none", + "enum": ["none", "all", "media", "bundles"] + }, + "poll": { + "type": "number", + "description": "Enable and define the file watching poll time period in milliseconds." + }, + "deleteOutputPath": { + "type": "boolean", + "description": "Delete the output path before building.", + "default": true + }, + "preserveSymlinks": { + "type": "boolean", + "description": "Do not use the real path when resolving modules. If unset then will default to `true` if NodeJS option --preserve-symlinks is set." + }, + "extractLicenses": { + "type": "boolean", + "description": "Extract all licenses in a separate file.", + "default": true + }, + "buildOptimizer": { + "type": "boolean", + "description": "Enables advanced build optimizations when using the 'aot' option.", + "default": true + }, + "namedChunks": { + "type": "boolean", + "description": "Use file name for lazy loaded chunks.", + "default": false + }, + "subresourceIntegrity": { + "type": "boolean", + "description": "Enables the use of subresource integrity validation.", + "default": false + }, + "serviceWorker": { + "type": "boolean", + "description": "Generates a service worker config for production builds.", + "default": false + }, + "ngswConfigPath": { + "type": "string", + "description": "Path to ngsw-config.json." + }, + "index": { + "description": "Configures the generation of the application's HTML index.", + "oneOf": [ + { + "type": "string", + "description": "The path of a file to use for the application's HTML index. The filename of the specified path will be used for the generated file and will be created in the root of the application's configured output path." + }, + { + "type": "object", + "description": "", + "properties": { + "input": { + "type": "string", + "minLength": 1, + "description": "The path of a file to use for the application's generated HTML index." + }, + "output": { + "type": "string", + "minLength": 1, + "default": "index.html", + "description": "The output path of the application's generated HTML index file. The full provided path will be used and will be considered relative to the application's configured output path." + } + }, + "required": ["input"] + } + ] + }, + "statsJson": { + "type": "boolean", + "description": "Generates a 'stats.json' file which can be analyzed using tools such as 'webpack-bundle-analyzer'.", + "default": false + }, + "budgets": { + "description": "Budget thresholds to ensure parts of your application stay within boundaries which you set.", + "type": "array", + "items": { + "$ref": "#/definitions/budget" + }, + "default": [] + }, + "webWorkerTsConfig": { + "type": "string", + "description": "TypeScript configuration for Web Worker modules." + }, + "crossOrigin": { + "type": "string", + "description": "Define the crossorigin attribute setting of elements that provide CORS support.", + "default": "none", + "enum": ["none", "anonymous", "use-credentials"] + }, + "allowedCommonJsDependencies": { + "description": "A list of CommonJS packages that are allowed to be used without a build time warning.", + "type": "array", + "items": { + "type": "string" + }, + "default": [] + } + }, + "additionalProperties": false, + "required": ["outputPath", "index", "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": [ + { + "type": "object", + "properties": { + "src": { + "type": "string", + "pattern": "\\.(([cm]?j|t)sx?|json)$" + }, + "replaceWith": { + "type": "string", + "pattern": "\\.(([cm]?j|t)sx?|json)$" + } + }, + "additionalProperties": false, + "required": ["src", "replaceWith"] + }, + { + "type": "object", + "properties": { + "replace": { + "type": "string", + "pattern": "\\.(([cm]?j|t)sx?|json)$" + }, + "with": { + "type": "string", + "pattern": "\\.(([cm]?j|t)sx?|json)$" + } + }, + "additionalProperties": false, + "required": ["replace", "with"] + } + ] + }, + "budget": { + "type": "object", + "properties": { + "type": { + "type": "string", + "description": "The type of budget.", + "enum": ["all", "allScript", "any", "anyScript", "anyComponentStyle", "bundle", "initial"] + }, + "name": { + "type": "string", + "description": "The name of the bundle." + }, + "baseline": { + "type": "string", + "description": "The baseline size for comparison." + }, + "maximumWarning": { + "type": "string", + "description": "The maximum threshold for warning relative to the baseline." + }, + "maximumError": { + "type": "string", + "description": "The maximum threshold for error relative to the baseline." + }, + "minimumWarning": { + "type": "string", + "description": "The minimum threshold for warning relative to the baseline." + }, + "minimumError": { + "type": "string", + "description": "The minimum threshold for error relative to the baseline." + }, + "warning": { + "type": "string", + "description": "The threshold for warning relative to the baseline (min & max)." + }, + "error": { + "type": "string", + "description": "The threshold for error relative to the baseline (min & max)." + } + }, + "additionalProperties": false, + "required": ["type"] + } + } +} diff --git a/artifacts/build-angular/src/builders/browser-rspack/webpack-factory-adapter.d.ts b/artifacts/build-angular/src/builders/browser-rspack/webpack-factory-adapter.d.ts new file mode 100644 index 00000000..c3018c97 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-rspack/webpack-factory-adapter.d.ts @@ -0,0 +1,3 @@ +import { Observable } from 'rxjs'; +import webpack from 'webpack'; +export declare function webpackFactory(options: any): Observable; diff --git a/artifacts/build-angular/src/builders/browser-rspack/webpack-factory-adapter.js b/artifacts/build-angular/src/builders/browser-rspack/webpack-factory-adapter.js new file mode 100644 index 00000000..5ea7b7d6 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser-rspack/webpack-factory-adapter.js @@ -0,0 +1,155 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.webpackFactory = void 0; +const cli_1 = require("@rspack/cli"); +const core_1 = require("@rspack/core"); +const rxjs_1 = require("rxjs"); +function webpackFactory(options) { + return (0, rxjs_1.from)(createWebpackFactoryFromRspackCLI(options)); +} +exports.webpackFactory = webpackFactory; +async function createWebpackFactoryFromRspackCLI(options) { + const rspackCommand = 'build'; + process.env.RSPACK_CONFIG_VALIDATE = 'loose'; + let nodeEnv = process?.env?.NODE_ENV; + let rspackCommandDefaultEnv = rspackCommand === 'build' ? 'production' : 'development'; + if (typeof options.nodeEnv === 'string') { + process.env.NODE_ENV = nodeEnv || options.nodeEnv; + } + else { + process.env.NODE_ENV = nodeEnv || rspackCommandDefaultEnv; + } + // let config = await this.loadConfig(options); + const cli = new cli_1.RspackCLI(); + const cliOptions = { + 'watch': false, + 'devtool': false, + 'analyze': false, + 'env': {}, + 'argv': {}, + }; + const config = await cli.buildConfig(webpackToRspack(options), cliOptions, rspackCommand); + + // Add tsconfig aliases + const result = require('tsconfig-paths').loadConfig(`${process.cwd()}/tsconfig.base.json`); + const alias = Object.keys(result.paths).reduce((acc, k) => { + acc[k] = require('path').join(process.cwd(), result.paths[k][0]); + return acc; + }, {}); + config.resolve.alias = alias; + + return (0, core_1.rspack)(config); +} +function webpackToRspack(options) { + const { mode, devtool, target, entry, profile, resolve, output, watch, experiments, optimization, module, plugins, } = options; + const convertResolve = (resolve = {}) => { + const { extensions } = resolve; + return { + extensions: extensions, + }; + }; + const convertOutput = (output) => { + const { uniqueName, hashFunction, clean, path, publicPath, filename, chunkFilename, crossOriginLoading, trustedTypes, scriptType, } = output; + return { + uniqueName, + // hashFunction, + clean, + path, + publicPath, + filename, + chunkFilename, + crossOriginLoading, + trustedTypes, + }; + }; + const convertExperiments = (experiments) => { + const { asyncWebAssembly } = experiments; + return { asyncWebAssembly }; + }; + const convertOptimization = (optimization) => { + const { minimize, runtimeChunk, splitChunks } = optimization; + const { cacheGroups } = splitChunks; + delete cacheGroups.common.enforce; + return { + // fixme: hacks + minimize: true, + // fixme: hacks + runtimeChunk: false, + splitChunks: { + // maxAsyncRequests: splitChunks?.maxAsyncRequests, + cacheGroups: { + default: cacheGroups['default'], + common: cacheGroups.common, + }, + }, + }; + }; + const convertModule = (module) => { + const { parser, rules } = module; + const wrapLoaderInUse = (rule) => { + if (!rule.loader) + return rule; + rule.use = rule.use || []; + rule.use.push({ loader: rule.loader }); + delete rule.loader; + return rule; + }; + const convertRules = (rules) => { + return rules + .filter((rule) => !rule.test.test('skip_css_rule.css')) + .filter((rule) => !rule.test.test('skip_css_rule.scss')) + .filter((rule) => rule.test.toString().indexOf('sass') === -1) + .filter((rule) => rule.test.toString().indexOf('less') === -1) + .map((rule) => wrapLoaderInUse(rule)); + }; + // fixme: hacks + delete parser.javascript.worker; + let _rules = convertRules(rules); + _rules = [ + ..._rules, + { + test: /\.?(scss)$/, + resourceQuery: /\?ngResource/, + use: [{ loader: 'raw-loader' }, { loader: 'sass-loader' }], + }, + ]; + return { + parser, + rules: _rules, + }; + }; + const convertPlugins = (plugins) => { + // fixme: hacks + const res = plugins + .filter((plugin) => plugin.apply.toString().indexOf('compiler.hooks.shutdown') === -1) + .filter((plugin) => plugin?.constructor?.name !== 'MiniCssExtractPlugin') + .filter((plugin) => plugin?.constructor?.name !== 'LicenseWebpackPlugin') + .filter((plugin) => plugin?.constructor?.name !== 'DedupeModuleResolvePlugin') + .filter((plugin) => plugin?.constructor?.name !== 'AnyComponentStyleBudgetChecker') + .filter((plugin) => plugin?.constructor?.name !== 'CommonJsUsageWarnPlugin') + // fixme: hacks + // .filter((plugin: any) => plugin?.constructor?.name !== 'ProgressPlugin') + .filter((plugin) => plugin?.constructor?.name !== 'StylesWebpackPlugin'); + // .filter((plugin) => plugin?.constructor?.name !== 'SuppressExtractedTextChunksWebpackPlugin') + return res; + }; + // const builtins = { html: [{ template: './src/index.html' }] }; + const res = { + mode, + devtool: devtool, + target: target, + entry, + resolve: convertResolve(resolve), + output: convertOutput(output), + watch, + experiments: convertExperiments(experiments), + optimization: convertOptimization(optimization), + // builtins, + module: convertModule(module), + plugins: convertPlugins(plugins), + // fixme: hacks + cache: true, + }; + return res; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"webpack-factory-adapter.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-rspack/webpack-factory-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import path from 'node:path';\nimport { RspackCLI } from '@rspack/cli';\nimport { DevTool, Mode, rspack, RspackOptions } from '@rspack/core';\nimport { from, Observable } from 'rxjs';\nimport { NamedChunksPlugin } from '../../webpack/plugins/named-chunks-plugin';\nimport { OccurrencesPlugin } from '../../webpack/plugins/occurrences-plugin';\nimport { AngularWebpackPlugin } from '@ngtools/webpack';\nimport webpack from 'webpack';\nimport { Target } from '@rspack/core/dist/config/types';\nimport { ProgressPlugin } from './plugins/progress-plugin';\n\nexport function webpackFactory(options: any) {\n  return from(createWebpackFactoryFromRspackCLI(options)) as unknown as Observable<typeof webpack>;\n}\n\nasync function createWebpackFactoryFromRspackCLI(options: any) {\n  const rspackCommand = 'build';\n  process.env.RSPACK_CONFIG_VALIDATE = 'loose';\n  let nodeEnv = process?.env?.NODE_ENV;\n  let rspackCommandDefaultEnv = rspackCommand === 'build' ? 'production' : 'development';\n  if (typeof options.nodeEnv === 'string') {\n    process.env.NODE_ENV = nodeEnv || options.nodeEnv;\n  } else {\n    process.env.NODE_ENV = nodeEnv || rspackCommandDefaultEnv;\n  }\n  // let config = await this.loadConfig(options);\n  const cli = new RspackCLI();\n  const cliOptions = {\n    'watch': false,\n    'devtool': false,\n    'analyze': false,\n    'env': {},\n    'argv': {},\n  };\n  const config = await cli.buildConfig(webpackToRspack(options), cliOptions, rspackCommand);\n\n  return rspack(config);\n}\n\nfunction webpackToRspack(options: webpack.Configuration): RspackOptions {\n  const {\n    mode,\n    devtool,\n    target,\n    entry,\n    profile,\n    resolve,\n    output,\n    watch,\n    experiments,\n    optimization,\n    module,\n    plugins,\n  } = options;\n\n  const convertResolve = (resolve: webpack.ResolveOptions = {}) => {\n    const { extensions } = resolve;\n    return {\n      extensions: extensions,\n    };\n  };\n\n  const convertOutput = (output: any) => {\n    const {\n      uniqueName,\n      hashFunction,\n      clean,\n      path,\n      publicPath,\n      filename,\n      chunkFilename,\n      crossOriginLoading,\n      trustedTypes,\n      scriptType,\n    } = output;\n    return {\n      uniqueName,\n      // hashFunction,\n      clean,\n      path,\n      publicPath,\n      filename,\n      chunkFilename,\n      crossOriginLoading,\n      trustedTypes,\n    };\n  };\n\n  const convertExperiments = (experiments: any) => {\n    const { asyncWebAssembly } = experiments;\n    return { asyncWebAssembly };\n  };\n\n  const convertOptimization = (optimization: any) => {\n    const { minimize, runtimeChunk, splitChunks } = optimization;\n\n    const { cacheGroups } = splitChunks;\n    delete cacheGroups.common.enforce;\n\n    return {\n      // fixme: hacks\n      minimize: true,\n      // fixme: hacks\n      runtimeChunk: false,\n      splitChunks: {\n        // maxAsyncRequests: splitChunks?.maxAsyncRequests,\n        cacheGroups: {\n          default: cacheGroups['default'],\n          common: cacheGroups.common,\n        },\n      },\n    };\n  };\n\n  const convertModule = (module: any) => {\n    const { parser, rules } = module;\n\n    const wrapLoaderInUse = (rule: any) => {\n      if (!rule.loader) return rule;\n      rule.use = rule.use || [];\n      rule.use.push({ loader: rule.loader });\n      delete rule.loader;\n\n      return rule;\n    };\n\n    const convertRules = (rules: any[]) => {\n      return rules\n        .filter((rule) => !rule.test.test('skip_css_rule.css'))\n        .filter((rule) => !rule.test.test('skip_css_rule.scss'))\n        .filter((rule) => rule.test.toString().indexOf('sass') === -1)\n        .filter((rule) => rule.test.toString().indexOf('less') === -1)\n        .map((rule) => wrapLoaderInUse(rule));\n    };\n\n    // fixme: hacks\n    delete parser.javascript.worker;\n\n    let _rules = convertRules(rules);\n    _rules = [\n      ..._rules,\n      {\n        test: /\\.?(scss)$/,\n        resourceQuery: /\\?ngResource/,\n        use: [{ loader: 'raw-loader' }, { loader: 'sass-loader' }],\n      },\n    ];\n    return {\n      parser,\n      rules: _rules,\n    };\n  };\n\n  const convertPlugins = (plugins: any) => {\n    // fixme: hacks\n    const res = plugins\n      .filter((plugin: any) => plugin.apply.toString().indexOf('compiler.hooks.shutdown') === -1)\n      .filter((plugin: any) => plugin?.constructor?.name !== 'MiniCssExtractPlugin')\n      .filter((plugin: any) => plugin?.constructor?.name !== 'LicenseWebpackPlugin')\n      .filter((plugin: any) => plugin?.constructor?.name !== 'DedupeModuleResolvePlugin')\n      .filter((plugin: any) => plugin?.constructor?.name !== 'AnyComponentStyleBudgetChecker')\n      .filter((plugin: any) => plugin?.constructor?.name !== 'CommonJsUsageWarnPlugin')\n      // fixme: hacks\n      // .filter((plugin: any) => plugin?.constructor?.name !== 'ProgressPlugin')\n      .filter((plugin: any) => plugin?.constructor?.name !== 'StylesWebpackPlugin');\n    // .filter((plugin) => plugin?.constructor?.name !== 'SuppressExtractedTextChunksWebpackPlugin')\n\n    return res;\n  };\n\n  // const builtins = { html: [{ template: './src/index.html' }] };\n\n  const res = {\n    mode,\n    devtool: devtool as DevTool,\n    target: target as Target,\n    entry,\n    resolve: convertResolve(resolve),\n    output: convertOutput(output),\n    watch,\n    experiments: convertExperiments(experiments),\n    optimization: convertOptimization(optimization),\n    // builtins,\n    module: convertModule(module),\n    plugins: convertPlugins(plugins),\n\n    // fixme: hacks\n    cache: true,\n  };\n\n  return res as any;\n}\n"]} diff --git a/artifacts/build-angular/src/builders/browser/index.d.ts b/artifacts/build-angular/src/builders/browser/index.d.ts new file mode 100644 index 00000000..5837b9b6 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser/index.d.ts @@ -0,0 +1,42 @@ +/** + * @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 { WebpackLoggingCallback } from '@angular-devkit/build-webpack'; +import { Observable } from 'rxjs'; +import webpack from 'webpack'; +import { ExecutionTransformer } from '../../transforms'; +import { IndexHtmlTransform } from '../../utils/index-file/index-html-generator'; +import { BuildEventStats } from '../../webpack/utils/stats'; +import { Schema as BrowserBuilderSchema } from './schema'; +/** + * @experimental Direct usage of this type is considered experimental. + */ +export type BrowserBuilderOutput = BuilderOutput & { + stats: BuildEventStats; + baseOutputPath: string; + outputs: { + locale?: string; + path: string; + baseHref?: string; + }[]; +}; +/** + * Maximum time in milliseconds for single build/rebuild + * This accounts for CI variability. + */ +export declare const BUILD_TIMEOUT = 30000; +/** + * @experimental Direct usage of this function is considered experimental. + */ +export declare function buildWebpackBrowser(options: BrowserBuilderSchema, context: BuilderContext, transforms?: { + webpackConfiguration?: ExecutionTransformer; + logging?: WebpackLoggingCallback; + indexHtml?: IndexHtmlTransform; +}): Observable; +declare const _default: import("../../../../architect/src/internal").Builder; +export default _default; diff --git a/artifacts/build-angular/src/builders/browser/index.js b/artifacts/build-angular/src/builders/browser/index.js new file mode 100644 index 00000000..8f516c66 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser/index.js @@ -0,0 +1,330 @@ +"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.buildWebpackBrowser = exports.BUILD_TIMEOUT = void 0; +const architect_1 = require("@angular-devkit/architect"); +const build_webpack_1 = require("@angular-devkit/build-webpack"); +const fs = __importStar(require("fs")); +const path = __importStar(require("path")); +const rxjs_1 = require("rxjs"); +const utils_1 = require("../../utils"); +const bundle_calculator_1 = require("../../utils/bundle-calculator"); +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 index_html_generator_1 = require("../../utils/index-file/index-html-generator"); +const normalize_cache_1 = require("../../utils/normalize-cache"); +const output_paths_1 = require("../../utils/output-paths"); +const package_chunk_sort_1 = require("../../utils/package-chunk-sort"); +const purge_cache_1 = require("../../utils/purge-cache"); +const service_worker_1 = require("../../utils/service-worker"); +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"); +const async_chunks_1 = require("../../webpack/utils/async-chunks"); +const helpers_1 = require("../../webpack/utils/helpers"); +const stats_1 = require("../../webpack/utils/stats"); +/** + * Maximum time in milliseconds for single build/rebuild + * This accounts for CI variability. + */ +exports.BUILD_TIMEOUT = 30000; +async function initialize(options, context, webpackConfigurationTransform) { + const originalOutputPath = options.outputPath; + // 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, context, (wco) => [ + (0, configs_1.getCommonConfig)(wco), + (0, configs_1.getStylesConfig)(wco), + ]); + let transformedConfig; + if (webpackConfigurationTransform) { + transformedConfig = await webpackConfigurationTransform(config); + } + if (options.deleteOutputPath) { + (0, utils_1.deleteOutputDir)(context.workspaceRoot, originalOutputPath); + } + return { config: transformedConfig || config, projectRoot, projectSourceRoot, i18n }; +} +/** + * @experimental Direct usage of this function is considered experimental. + */ +// eslint-disable-next-line max-lines-per-function +function buildWebpackBrowser(options, context, transforms = {}) { + const projectName = context.target?.project; + if (!projectName) { + throw new Error('The builder requires a target.'); + } + const baseOutputPath = path.resolve(context.workspaceRoot, options.outputPath); + let outputPaths; + // Check Angular version. + (0, version_1.assertCompatibleAngularVersion)(context.workspaceRoot); + return (0, rxjs_1.from)(context.getProjectMetadata(projectName)).pipe((0, rxjs_1.switchMap)(async (projectMetadata) => { + var _a; + // Purge old build disk cache. + await (0, purge_cache_1.purgeStaleBuildCache)(context); + // Initialize builder + const initialization = await initialize(options, context, transforms.webpackConfiguration); + // Add index file to watched files. + if (options.watch) { + const indexInputFile = path.join(context.workspaceRoot, (0, webpack_browser_config_1.getIndexInputFile)(options.index)); + (_a = initialization.config).plugins ?? (_a.plugins = []); + initialization.config.plugins.push({ + apply: (compiler) => { + compiler.hooks.thisCompilation.tap('build-angular', (compilation) => { + compilation.fileDependencies.add(indexInputFile); + }); + }, + }); + } + return { + ...initialization, + cacheOptions: (0, normalize_cache_1.normalizeCacheOptions)(projectMetadata, context.workspaceRoot), + }; + }), (0, rxjs_1.switchMap)( + // eslint-disable-next-line max-lines-per-function + ({ config, projectRoot, projectSourceRoot, i18n, cacheOptions }) => { + const normalizedOptimization = (0, utils_1.normalizeOptimization)(options.optimization); + return (0, build_webpack_1.runWebpack)(config, context, { + webpackFactory: require('webpack'), + logging: transforms.logging || + ((stats, config) => { + if (options.verbose) { + context.logger.info(stats.toString(config.stats)); + } + }), + }).pipe((0, rxjs_1.concatMap)( + // eslint-disable-next-line max-lines-per-function + async (buildEvent) => { + const spinner = new spinner_1.Spinner(); + spinner.enabled = options.progress !== false; + const { success, emittedFiles = [], outputPath: webpackOutputPath } = buildEvent; + const webpackRawStats = buildEvent.webpackStats; + if (!webpackRawStats) { + throw new Error('Webpack stats build result is required.'); + } + // Fix incorrectly set `initial` value on chunks. + const extraEntryPoints = [ + ...(0, helpers_1.normalizeExtraEntryPoints)(options.styles || [], 'styles'), + ...(0, helpers_1.normalizeExtraEntryPoints)(options.scripts || [], 'scripts'), + ]; + const webpackStats = { + ...webpackRawStats, + chunks: (0, async_chunks_1.markAsyncChunksNonInitial)(webpackRawStats, extraEntryPoints), + }; + if (!success) { + // If using bundle downleveling then there is only one build + // If it fails show any diagnostic messages and bail + if ((0, stats_1.statsHasWarnings)(webpackStats)) { + context.logger.warn((0, stats_1.statsWarningsToString)(webpackStats, { colors: true })); + } + if ((0, stats_1.statsHasErrors)(webpackStats)) { + context.logger.error((0, stats_1.statsErrorsToString)(webpackStats, { colors: true })); + } + return { + webpackStats: webpackRawStats, + output: { success: false }, + }; + } + else { + outputPaths = (0, output_paths_1.ensureOutputPaths)(baseOutputPath, i18n); + const scriptsEntryPointName = (0, helpers_1.normalizeExtraEntryPoints)(options.scripts || [], 'scripts').map((x) => x.bundleName); + if (i18n.shouldInline) { + const success = await (0, i18n_inlining_1.i18nInlineEmittedFiles)(context, emittedFiles, i18n, baseOutputPath, Array.from(outputPaths.values()), scriptsEntryPointName, webpackOutputPath, options.i18nMissingTranslation); + if (!success) { + return { + webpackStats: webpackRawStats, + output: { success: false }, + }; + } + } + // Check for budget errors and display them to the user. + const budgets = options.budgets; + let budgetFailures; + if (budgets?.length) { + budgetFailures = [...(0, bundle_calculator_1.checkBudgets)(budgets, webpackStats)]; + for (const { severity, message } of budgetFailures) { + switch (severity) { + case bundle_calculator_1.ThresholdSeverity.Warning: + webpackStats.warnings?.push({ message }); + break; + case bundle_calculator_1.ThresholdSeverity.Error: + webpackStats.errors?.push({ message }); + break; + default: + assertNever(severity); + } + } + } + const buildSuccess = success && !(0, stats_1.statsHasErrors)(webpackStats); + if (buildSuccess) { + // Copy assets + if (!options.watch && options.assets?.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, + }, + webpackStats: webpackRawStats, + }; + } + } + if (options.index) { + spinner.start('Generating index html...'); + const entrypoints = (0, package_chunk_sort_1.generateEntryPoints)({ + scripts: options.scripts ?? [], + styles: options.styles ?? [], + }); + const indexHtmlGenerator = new index_html_generator_1.IndexHtmlGenerator({ + cache: cacheOptions, + indexPath: path.join(context.workspaceRoot, (0, webpack_browser_config_1.getIndexInputFile)(options.index)), + entrypoints, + deployUrl: options.deployUrl, + sri: options.subresourceIntegrity, + optimization: normalizedOptimization, + crossOrigin: options.crossOrigin, + postTransform: transforms.indexHtml, + }); + let hasErrors = false; + for (const [locale, outputPath] of outputPaths.entries()) { + try { + const { content, warnings, errors } = await indexHtmlGenerator.process({ + baseHref: getLocaleBaseHref(i18n, locale) ?? options.baseHref, + // i18nLocale is used when Ivy is disabled + lang: locale || undefined, + outputPath, + files: mapEmittedFilesToFileInfo(emittedFiles), + }); + if (warnings.length || errors.length) { + spinner.stop(); + warnings.forEach((m) => context.logger.warn(m)); + errors.forEach((m) => { + context.logger.error(m); + hasErrors = true; + }); + spinner.start(); + } + const indexOutput = path.join(outputPath, (0, webpack_browser_config_1.getIndexOutputFile)(options.index)); + await fs.promises.mkdir(path.dirname(indexOutput), { recursive: true }); + await fs.promises.writeFile(indexOutput, content); + } + catch (error) { + spinner.fail('Index html generation failed.'); + (0, error_1.assertIsError)(error); + return { + webpackStats: webpackRawStats, + output: { success: false, error: error.message }, + }; + } + } + if (hasErrors) { + spinner.fail('Index html generation failed.'); + return { + webpackStats: webpackRawStats, + output: { success: false }, + }; + } + else { + spinner.succeed('Index html generation complete.'); + } + } + if (options.serviceWorker) { + spinner.start('Generating service worker...'); + for (const [locale, outputPath] of outputPaths.entries()) { + try { + await (0, service_worker_1.augmentAppWithServiceWorker)(projectRoot, context.workspaceRoot, outputPath, getLocaleBaseHref(i18n, locale) ?? options.baseHref ?? '/', options.ngswConfigPath); + } + catch (error) { + spinner.fail('Service worker generation failed.'); + (0, error_1.assertIsError)(error); + return { + webpackStats: webpackRawStats, + output: { success: false, error: error.message }, + }; + } + } + spinner.succeed('Service worker generation complete.'); + } + } + (0, stats_1.webpackStatsLogger)(context.logger, webpackStats, config, budgetFailures); + return { + webpackStats: webpackRawStats, + output: { success: buildSuccess }, + }; + } + }), (0, rxjs_1.map)(({ output: event, webpackStats }) => ({ + ...event, + stats: (0, stats_1.generateBuildEventStats)(webpackStats, options), + baseOutputPath, + outputs: (outputPaths && + [...outputPaths.entries()].map(([locale, path]) => ({ + locale, + path, + baseHref: getLocaleBaseHref(i18n, locale) ?? options.baseHref, + }))) || { + path: baseOutputPath, + baseHref: options.baseHref, + }, + }))); + })); + function getLocaleBaseHref(i18n, locale) { + if (i18n.locales[locale] && i18n.locales[locale]?.baseHref !== '') { + return (0, utils_1.urlJoin)(options.baseHref || '', i18n.locales[locale].baseHref ?? `/${locale}/`); + } + return undefined; + } +} +exports.buildWebpackBrowser = buildWebpackBrowser; +function assertNever(input) { + throw new Error(`Unexpected call to assertNever() with input: ${JSON.stringify(input, null /* replacer */, 4 /* tabSize */)}`); +} +function mapEmittedFilesToFileInfo(files = []) { + const filteredFiles = []; + for (const { file, name, extension, initial } of files) { + if (name && initial) { + filteredFiles.push({ file, extension, name }); + } + } + return filteredFiles; +} +exports.default = (0, architect_1.createBuilder)(buildWebpackBrowser); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser/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 { BuilderContext, BuilderOutput, createBuilder } from '@angular-devkit/architect';\nimport { EmittedFiles, WebpackLoggingCallback, runWebpack } from '@angular-devkit/build-webpack';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { Observable, concatMap, from, map, switchMap } from 'rxjs';\nimport webpack, { StatsCompilation } from 'webpack';\nimport { ExecutionTransformer } from '../../transforms';\nimport {\n  deleteOutputDir,\n  normalizeAssetPatterns,\n  normalizeOptimization,\n  urlJoin,\n} from '../../utils';\nimport {\n  BudgetCalculatorResult,\n  ThresholdSeverity,\n  checkBudgets,\n} from '../../utils/bundle-calculator';\nimport { colors } from '../../utils/color';\nimport { copyAssets } from '../../utils/copy-assets';\nimport { assertIsError } from '../../utils/error';\nimport { i18nInlineEmittedFiles } from '../../utils/i18n-inlining';\nimport { I18nOptions } from '../../utils/i18n-options';\nimport { FileInfo } from '../../utils/index-file/augment-index-html';\nimport {\n  IndexHtmlGenerator,\n  IndexHtmlTransform,\n} from '../../utils/index-file/index-html-generator';\nimport { normalizeCacheOptions } from '../../utils/normalize-cache';\nimport { ensureOutputPaths } from '../../utils/output-paths';\nimport { generateEntryPoints } from '../../utils/package-chunk-sort';\nimport { purgeStaleBuildCache } from '../../utils/purge-cache';\nimport { augmentAppWithServiceWorker } from '../../utils/service-worker';\nimport { Spinner } from '../../utils/spinner';\nimport { assertCompatibleAngularVersion } from '../../utils/version';\nimport {\n  generateI18nBrowserWebpackConfigFromContext,\n  getIndexInputFile,\n  getIndexOutputFile,\n} from '../../utils/webpack-browser-config';\nimport { getCommonConfig, getStylesConfig } from '../../webpack/configs';\nimport { markAsyncChunksNonInitial } from '../../webpack/utils/async-chunks';\nimport { normalizeExtraEntryPoints } from '../../webpack/utils/helpers';\nimport {\n  BuildEventStats,\n  generateBuildEventStats,\n  statsErrorsToString,\n  statsHasErrors,\n  statsHasWarnings,\n  statsWarningsToString,\n  webpackStatsLogger,\n} from '../../webpack/utils/stats';\nimport { Schema as BrowserBuilderSchema } from './schema';\n\n/**\n * @experimental Direct usage of this type is considered experimental.\n */\nexport type BrowserBuilderOutput = BuilderOutput & {\n  stats: BuildEventStats;\n  baseOutputPath: string;\n  outputs: {\n    locale?: string;\n    path: string;\n    baseHref?: string;\n  }[];\n};\n\n/**\n * Maximum time in milliseconds for single build/rebuild\n * This accounts for CI variability.\n */\nexport const BUILD_TIMEOUT = 30_000;\n\nasync function initialize(\n  options: BrowserBuilderSchema,\n  context: BuilderContext,\n  webpackConfigurationTransform?: ExecutionTransformer<webpack.Configuration>,\n): Promise<{\n  config: webpack.Configuration;\n  projectRoot: string;\n  projectSourceRoot?: string;\n  i18n: I18nOptions;\n}> {\n  const originalOutputPath = options.outputPath;\n\n  // Assets are processed directly by the builder except when watching\n  const adjustedOptions = options.watch ? options : { ...options, assets: [] };\n\n  const { config, projectRoot, projectSourceRoot, i18n } =\n    await generateI18nBrowserWebpackConfigFromContext(adjustedOptions, context, (wco) => [\n      getCommonConfig(wco),\n      getStylesConfig(wco),\n    ]);\n\n  let transformedConfig;\n  if (webpackConfigurationTransform) {\n    transformedConfig = await webpackConfigurationTransform(config);\n  }\n\n  if (options.deleteOutputPath) {\n    deleteOutputDir(context.workspaceRoot, originalOutputPath);\n  }\n\n  return { config: transformedConfig || config, projectRoot, projectSourceRoot, i18n };\n}\n\n/**\n * @experimental Direct usage of this function is considered experimental.\n */\n// eslint-disable-next-line max-lines-per-function\nexport function buildWebpackBrowser(\n  options: BrowserBuilderSchema,\n  context: BuilderContext,\n  transforms: {\n    webpackConfiguration?: ExecutionTransformer<webpack.Configuration>;\n    logging?: WebpackLoggingCallback;\n    indexHtml?: IndexHtmlTransform;\n  } = {},\n): Observable<BrowserBuilderOutput> {\n  const projectName = context.target?.project;\n  if (!projectName) {\n    throw new Error('The builder requires a target.');\n  }\n\n  const baseOutputPath = path.resolve(context.workspaceRoot, options.outputPath);\n  let outputPaths: undefined | Map<string, string>;\n\n  // Check Angular version.\n  assertCompatibleAngularVersion(context.workspaceRoot);\n\n  return from(context.getProjectMetadata(projectName)).pipe(\n    switchMap(async (projectMetadata) => {\n      // Purge old build disk cache.\n      await purgeStaleBuildCache(context);\n\n      // Initialize builder\n      const initialization = await initialize(options, context, transforms.webpackConfiguration);\n\n      // Add index file to watched files.\n      if (options.watch) {\n        const indexInputFile = path.join(context.workspaceRoot, getIndexInputFile(options.index));\n        initialization.config.plugins ??= [];\n        initialization.config.plugins.push({\n          apply: (compiler: webpack.Compiler) => {\n            compiler.hooks.thisCompilation.tap('build-angular', (compilation) => {\n              compilation.fileDependencies.add(indexInputFile);\n            });\n          },\n        });\n      }\n\n      return {\n        ...initialization,\n        cacheOptions: normalizeCacheOptions(projectMetadata, context.workspaceRoot),\n      };\n    }),\n    switchMap(\n      // eslint-disable-next-line max-lines-per-function\n      ({ config, projectRoot, projectSourceRoot, i18n, cacheOptions }) => {\n        const normalizedOptimization = normalizeOptimization(options.optimization);\n\n        return runWebpack(config, context, {\n          webpackFactory: require('webpack') as typeof webpack,\n          logging:\n            transforms.logging ||\n            ((stats, config) => {\n              if (options.verbose) {\n                context.logger.info(stats.toString(config.stats));\n              }\n            }),\n        }).pipe(\n          concatMap(\n            // eslint-disable-next-line max-lines-per-function\n            async (\n              buildEvent,\n            ): Promise<{ output: BuilderOutput; webpackStats: StatsCompilation }> => {\n              const spinner = new Spinner();\n              spinner.enabled = options.progress !== false;\n\n              const { success, emittedFiles = [], outputPath: webpackOutputPath } = buildEvent;\n              const webpackRawStats = buildEvent.webpackStats;\n              if (!webpackRawStats) {\n                throw new Error('Webpack stats build result is required.');\n              }\n\n              // Fix incorrectly set `initial` value on chunks.\n              const extraEntryPoints = [\n                ...normalizeExtraEntryPoints(options.styles || [], 'styles'),\n                ...normalizeExtraEntryPoints(options.scripts || [], 'scripts'),\n              ];\n\n              const webpackStats = {\n                ...webpackRawStats,\n                chunks: markAsyncChunksNonInitial(webpackRawStats, extraEntryPoints),\n              };\n\n              if (!success) {\n                // If using bundle downleveling then there is only one build\n                // If it fails show any diagnostic messages and bail\n                if (statsHasWarnings(webpackStats)) {\n                  context.logger.warn(statsWarningsToString(webpackStats, { colors: true }));\n                }\n                if (statsHasErrors(webpackStats)) {\n                  context.logger.error(statsErrorsToString(webpackStats, { colors: true }));\n                }\n\n                return {\n                  webpackStats: webpackRawStats,\n                  output: { success: false },\n                };\n              } else {\n                outputPaths = ensureOutputPaths(baseOutputPath, i18n);\n\n                const scriptsEntryPointName = normalizeExtraEntryPoints(\n                  options.scripts || [],\n                  'scripts',\n                ).map((x) => x.bundleName);\n\n                if (i18n.shouldInline) {\n                  const success = await i18nInlineEmittedFiles(\n                    context,\n                    emittedFiles,\n                    i18n,\n                    baseOutputPath,\n                    Array.from(outputPaths.values()),\n                    scriptsEntryPointName,\n                    webpackOutputPath,\n                    options.i18nMissingTranslation,\n                  );\n                  if (!success) {\n                    return {\n                      webpackStats: webpackRawStats,\n                      output: { success: false },\n                    };\n                  }\n                }\n\n                // Check for budget errors and display them to the user.\n                const budgets = options.budgets;\n                let budgetFailures: BudgetCalculatorResult[] | undefined;\n                if (budgets?.length) {\n                  budgetFailures = [...checkBudgets(budgets, webpackStats)];\n                  for (const { severity, message } of budgetFailures) {\n                    switch (severity) {\n                      case ThresholdSeverity.Warning:\n                        webpackStats.warnings?.push({ message });\n                        break;\n                      case ThresholdSeverity.Error:\n                        webpackStats.errors?.push({ message });\n                        break;\n                      default:\n                        assertNever(severity);\n                    }\n                  }\n                }\n\n                const buildSuccess = success && !statsHasErrors(webpackStats);\n                if (buildSuccess) {\n                  // Copy assets\n                  if (!options.watch && options.assets?.length) {\n                    spinner.start('Copying assets...');\n                    try {\n                      await copyAssets(\n                        normalizeAssetPatterns(\n                          options.assets,\n                          context.workspaceRoot,\n                          projectRoot,\n                          projectSourceRoot,\n                        ),\n                        Array.from(outputPaths.values()),\n                        context.workspaceRoot,\n                      );\n                      spinner.succeed('Copying assets complete.');\n                    } catch (err) {\n                      spinner.fail(colors.redBright('Copying of assets failed.'));\n                      assertIsError(err);\n\n                      return {\n                        output: {\n                          success: false,\n                          error: 'Unable to copy assets: ' + err.message,\n                        },\n                        webpackStats: webpackRawStats,\n                      };\n                    }\n                  }\n\n                  if (options.index) {\n                    spinner.start('Generating index html...');\n\n                    const entrypoints = generateEntryPoints({\n                      scripts: options.scripts ?? [],\n                      styles: options.styles ?? [],\n                    });\n\n                    const indexHtmlGenerator = new IndexHtmlGenerator({\n                      cache: cacheOptions,\n                      indexPath: path.join(context.workspaceRoot, getIndexInputFile(options.index)),\n                      entrypoints,\n                      deployUrl: options.deployUrl,\n                      sri: options.subresourceIntegrity,\n                      optimization: normalizedOptimization,\n                      crossOrigin: options.crossOrigin,\n                      postTransform: transforms.indexHtml,\n                    });\n\n                    let hasErrors = false;\n                    for (const [locale, outputPath] of outputPaths.entries()) {\n                      try {\n                        const { content, warnings, errors } = await indexHtmlGenerator.process({\n                          baseHref: getLocaleBaseHref(i18n, locale) ?? options.baseHref,\n                          // i18nLocale is used when Ivy is disabled\n                          lang: locale || undefined,\n                          outputPath,\n                          files: mapEmittedFilesToFileInfo(emittedFiles),\n                        });\n\n                        if (warnings.length || errors.length) {\n                          spinner.stop();\n                          warnings.forEach((m) => context.logger.warn(m));\n                          errors.forEach((m) => {\n                            context.logger.error(m);\n                            hasErrors = true;\n                          });\n                          spinner.start();\n                        }\n\n                        const indexOutput = path.join(\n                          outputPath,\n                          getIndexOutputFile(options.index),\n                        );\n                        await fs.promises.mkdir(path.dirname(indexOutput), { recursive: true });\n                        await fs.promises.writeFile(indexOutput, content);\n                      } catch (error) {\n                        spinner.fail('Index html generation failed.');\n                        assertIsError(error);\n\n                        return {\n                          webpackStats: webpackRawStats,\n                          output: { success: false, error: error.message },\n                        };\n                      }\n                    }\n\n                    if (hasErrors) {\n                      spinner.fail('Index html generation failed.');\n\n                      return {\n                        webpackStats: webpackRawStats,\n                        output: { success: false },\n                      };\n                    } else {\n                      spinner.succeed('Index html generation complete.');\n                    }\n                  }\n\n                  if (options.serviceWorker) {\n                    spinner.start('Generating service worker...');\n                    for (const [locale, outputPath] of outputPaths.entries()) {\n                      try {\n                        await augmentAppWithServiceWorker(\n                          projectRoot,\n                          context.workspaceRoot,\n                          outputPath,\n                          getLocaleBaseHref(i18n, locale) ?? options.baseHref ?? '/',\n                          options.ngswConfigPath,\n                        );\n                      } catch (error) {\n                        spinner.fail('Service worker generation failed.');\n                        assertIsError(error);\n\n                        return {\n                          webpackStats: webpackRawStats,\n                          output: { success: false, error: error.message },\n                        };\n                      }\n                    }\n\n                    spinner.succeed('Service worker generation complete.');\n                  }\n                }\n\n                webpackStatsLogger(context.logger, webpackStats, config, budgetFailures);\n\n                return {\n                  webpackStats: webpackRawStats,\n                  output: { success: buildSuccess },\n                };\n              }\n            },\n          ),\n          map(\n            ({ output: event, webpackStats }) =>\n              ({\n                ...event,\n                stats: generateBuildEventStats(webpackStats, options),\n                baseOutputPath,\n                outputs: (outputPaths &&\n                  [...outputPaths.entries()].map(([locale, path]) => ({\n                    locale,\n                    path,\n                    baseHref: getLocaleBaseHref(i18n, locale) ?? options.baseHref,\n                  }))) || {\n                  path: baseOutputPath,\n                  baseHref: options.baseHref,\n                },\n              } as BrowserBuilderOutput),\n          ),\n        );\n      },\n    ),\n  );\n\n  function getLocaleBaseHref(i18n: I18nOptions, locale: string): string | undefined {\n    if (i18n.locales[locale] && i18n.locales[locale]?.baseHref !== '') {\n      return urlJoin(options.baseHref || '', i18n.locales[locale].baseHref ?? `/${locale}/`);\n    }\n\n    return undefined;\n  }\n}\n\nfunction assertNever(input: never): never {\n  throw new Error(\n    `Unexpected call to assertNever() with input: ${JSON.stringify(\n      input,\n      null /* replacer */,\n      4 /* tabSize */,\n    )}`,\n  );\n}\n\nfunction mapEmittedFilesToFileInfo(files: EmittedFiles[] = []): FileInfo[] {\n  const filteredFiles: FileInfo[] = [];\n  for (const { file, name, extension, initial } of files) {\n    if (name && initial) {\n      filteredFiles.push({ file, extension, name });\n    }\n  }\n\n  return filteredFiles;\n}\n\nexport default createBuilder<BrowserBuilderSchema>(buildWebpackBrowser);\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser/schema.d.ts b/artifacts/build-angular/src/builders/browser/schema.d.ts new file mode 100644 index 00000000..44729a7b --- /dev/null +++ b/artifacts/build-angular/src/builders/browser/schema.d.ts @@ -0,0 +1,428 @@ +/** + * Browser target options + */ +export interface Schema { + /** + * A list of CommonJS packages that are allowed to be used without a build time warning. + */ + allowedCommonJsDependencies?: string[]; + /** + * Build using Ahead of Time compilation. + */ + aot?: boolean; + /** + * List of static application assets. + */ + assets?: AssetPattern[]; + /** + * Base url for the application being built. + */ + baseHref?: string; + /** + * Budget thresholds to ensure parts of your application stay within boundaries which you + * set. + */ + budgets?: Budget[]; + /** + * Enables advanced build optimizations when using the 'aot' option. + */ + buildOptimizer?: boolean; + /** + * Generate a seperate bundle containing code used across multiple bundles. + */ + commonChunk?: boolean; + /** + * Define the crossorigin attribute setting of elements that provide CORS support. + */ + crossOrigin?: CrossOrigin; + /** + * Delete the output path before building. + */ + deleteOutputPath?: boolean; + /** + * URL where files will be deployed. + * @deprecated Use "baseHref" option, "APP_BASE_HREF" DI token or a combination of both + * instead. For more information, see https://angular.io/guide/deployment#the-deploy-url. + */ + deployUrl?: string; + /** + * Extract all licenses in a separate file. + */ + extractLicenses?: boolean; + /** + * Replace compilation source files with other compilation source files in the build. + */ + fileReplacements?: FileReplacement[]; + /** + * How to handle duplicate translations for i18n. + */ + i18nDuplicateTranslation?: I18NTranslation; + /** + * How to handle missing translations for i18n. + */ + i18nMissingTranslation?: I18NTranslation; + /** + * Configures the generation of the application's HTML index. + */ + index: IndexUnion; + /** + * The stylesheet language to use for the application's inline component styles. + */ + inlineStyleLanguage?: InlineStyleLanguage; + /** + * Translate the bundles in one or more locales. + */ + localize?: Localize; + /** + * The full path for the main entry point to the app, relative to the current workspace. + */ + main: string; + /** + * Use file name for lazy loaded chunks. + */ + namedChunks?: boolean; + /** + * Path to ngsw-config.json. + */ + ngswConfigPath?: string; + /** + * Enables optimization of the build output. Including minification of scripts and styles, + * tree-shaking, dead-code elimination, inlining of critical CSS and fonts inlining. For + * more information, see + * https://angular.io/guide/workspace-config#optimization-configuration. + */ + optimization?: OptimizationUnion; + /** + * Define the output filename cache-busting hashing mode. + */ + outputHashing?: OutputHashing; + /** + * The full path for the new output directory, relative to the current workspace. + * By default, writes output to a folder named dist/ in the current project. + */ + outputPath: string; + /** + * Enable and define the file watching poll time period in milliseconds. + */ + poll?: number; + /** + * Polyfills to be included in the build. + */ + polyfills?: Polyfills; + /** + * Do not use the real path when resolving modules. If unset then will default to `true` if + * NodeJS option --preserve-symlinks is set. + */ + preserveSymlinks?: boolean; + /** + * Log progress to the console while building. + */ + progress?: boolean; + /** + * The path where style resources will be placed, relative to outputPath. + */ + resourcesOutputPath?: string; + /** + * Global scripts to be included in the build. + */ + scripts?: ScriptElement[]; + /** + * Generates a service worker config for production builds. + */ + serviceWorker?: boolean; + /** + * Output source maps for scripts and styles. For more information, see + * https://angular.io/guide/workspace-config#source-map-configuration. + */ + sourceMap?: SourceMapUnion; + /** + * Generates a 'stats.json' file which can be analyzed using tools such as + * 'webpack-bundle-analyzer'. + */ + statsJson?: boolean; + /** + * Options to pass to style preprocessors. + */ + stylePreprocessorOptions?: StylePreprocessorOptions; + /** + * Global styles to be included in the build. + */ + styles?: StyleElement[]; + /** + * Enables the use of subresource integrity validation. + */ + subresourceIntegrity?: boolean; + /** + * The full path for the TypeScript configuration file, relative to the current workspace. + */ + tsConfig: string; + /** + * Generate a seperate bundle containing only vendor libraries. This option should only be + * used for development to reduce the incremental compilation time. + */ + vendorChunk?: boolean; + /** + * Adds more details to output logging. + */ + verbose?: boolean; + /** + * Run build when files change. + */ + watch?: boolean; + /** + * TypeScript configuration for Web Worker modules. + */ + webWorkerTsConfig?: string; +} +export 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 Budget { + /** + * The baseline size for comparison. + */ + baseline?: string; + /** + * The threshold for error relative to the baseline (min & max). + */ + error?: string; + /** + * The maximum threshold for error relative to the baseline. + */ + maximumError?: string; + /** + * The maximum threshold for warning relative to the baseline. + */ + maximumWarning?: string; + /** + * The minimum threshold for error relative to the baseline. + */ + minimumError?: string; + /** + * The minimum threshold for warning relative to the baseline. + */ + minimumWarning?: string; + /** + * The name of the bundle. + */ + name?: string; + /** + * The type of budget. + */ + type: Type; + /** + * The threshold for warning relative to the baseline (min & max). + */ + warning?: string; +} +/** + * The type of budget. + */ +export declare enum Type { + All = "all", + AllScript = "allScript", + Any = "any", + AnyComponentStyle = "anyComponentStyle", + AnyScript = "anyScript", + Bundle = "bundle", + Initial = "initial" +} +/** + * Define the crossorigin attribute setting of elements that provide CORS support. + */ +export declare enum CrossOrigin { + Anonymous = "anonymous", + None = "none", + UseCredentials = "use-credentials" +} +export interface FileReplacement { + replace?: string; + replaceWith?: string; + src?: string; + with?: string; +} +/** + * How to handle duplicate translations for i18n. + * + * How to handle missing translations for i18n. + */ +export declare enum I18NTranslation { + Error = "error", + Ignore = "ignore", + Warning = "warning" +} +/** + * Configures the generation of the application's HTML index. + */ +export type IndexUnion = IndexObject | string; +export interface IndexObject { + /** + * The path of a file to use for the application's generated HTML index. + */ + input: string; + /** + * The output path of the application's generated HTML index file. The full provided path + * will be used and will be considered relative to the application's configured output path. + */ + output?: string; + [property: string]: any; +} +/** + * The stylesheet language to use for the application's inline component styles. + */ +export declare enum InlineStyleLanguage { + Css = "css", + Less = "less", + Sass = "sass", + Scss = "scss" +} +/** + * Translate the bundles in one or more locales. + */ +export type Localize = string[] | boolean; +/** + * Enables optimization of the build output. Including minification of scripts and styles, + * tree-shaking, dead-code elimination, inlining of critical CSS and fonts inlining. For + * more information, see + * https://angular.io/guide/workspace-config#optimization-configuration. + */ +export type OptimizationUnion = boolean | OptimizationClass; +export interface OptimizationClass { + /** + * Enables optimization for fonts. This option requires internet access. `HTTPS_PROXY` + * environment variable can be used to specify a proxy server. + */ + fonts?: FontsUnion; + /** + * Enables optimization of the scripts output. + */ + scripts?: boolean; + /** + * Enables optimization of the styles output. + */ + styles?: StylesUnion; +} +/** + * Enables optimization for fonts. This option requires internet access. `HTTPS_PROXY` + * environment variable can be used to specify a proxy server. + */ +export type FontsUnion = boolean | FontsClass; +export interface FontsClass { + /** + * Reduce render blocking requests by inlining external Google Fonts and Adobe Fonts CSS + * definitions in the application's HTML index file. This option requires internet access. + * `HTTPS_PROXY` environment variable can be used to specify a proxy server. + */ + inline?: boolean; +} +/** + * Enables optimization of the styles output. + */ +export type StylesUnion = boolean | StylesClass; +export interface StylesClass { + /** + * Extract and inline critical CSS definitions to improve first paint time. + */ + inlineCritical?: boolean; + /** + * Minify CSS definitions by removing extraneous whitespace and comments, merging + * identifiers and minimizing values. + */ + minify?: boolean; +} +/** + * Define the output filename cache-busting hashing mode. + */ +export declare enum OutputHashing { + All = "all", + Bundles = "bundles", + Media = "media", + None = "none" +} +/** + * Polyfills to be included in the build. + */ +export type Polyfills = string[] | string; +export type ScriptElement = ScriptClass | string; +export interface ScriptClass { + /** + * The bundle name for this extra entry point. + */ + bundleName?: string; + /** + * If the bundle will be referenced in the HTML file. + */ + inject?: boolean; + /** + * The file to include. + */ + input: string; +} +/** + * Output source maps for scripts and styles. For more information, see + * https://angular.io/guide/workspace-config#source-map-configuration. + */ +export type SourceMapUnion = boolean | SourceMapClass; +export interface SourceMapClass { + /** + * Output source maps used for error reporting tools. + */ + hidden?: boolean; + /** + * Output source maps for all scripts. + */ + scripts?: boolean; + /** + * Output source maps for all styles. + */ + styles?: boolean; + /** + * Resolve vendor packages source maps. + */ + vendor?: boolean; +} +/** + * Options to pass to style preprocessors. + */ +export interface StylePreprocessorOptions { + /** + * Paths to include. Paths will be resolved to workspace root. + */ + includePaths?: string[]; +} +export type StyleElement = StyleClass | string; +export interface StyleClass { + /** + * The bundle name for this extra entry point. + */ + bundleName?: string; + /** + * If the bundle will be referenced in the HTML file. + */ + inject?: boolean; + /** + * The file to include. + */ + input: string; +} diff --git a/artifacts/build-angular/src/builders/browser/schema.js b/artifacts/build-angular/src/builders/browser/schema.js new file mode 100644 index 00000000..d99f7c75 --- /dev/null +++ b/artifacts/build-angular/src/builders/browser/schema.js @@ -0,0 +1,59 @@ +"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 }); +exports.OutputHashing = exports.InlineStyleLanguage = exports.I18NTranslation = exports.CrossOrigin = exports.Type = void 0; +/** + * The type of budget. + */ +var Type; +(function (Type) { + Type["All"] = "all"; + Type["AllScript"] = "allScript"; + Type["Any"] = "any"; + Type["AnyComponentStyle"] = "anyComponentStyle"; + Type["AnyScript"] = "anyScript"; + Type["Bundle"] = "bundle"; + Type["Initial"] = "initial"; +})(Type = exports.Type || (exports.Type = {})); +/** + * Define the crossorigin attribute setting of elements that provide CORS support. + */ +var CrossOrigin; +(function (CrossOrigin) { + CrossOrigin["Anonymous"] = "anonymous"; + CrossOrigin["None"] = "none"; + CrossOrigin["UseCredentials"] = "use-credentials"; +})(CrossOrigin = exports.CrossOrigin || (exports.CrossOrigin = {})); +/** + * How to handle duplicate translations for i18n. + * + * How to handle missing translations for i18n. + */ +var I18NTranslation; +(function (I18NTranslation) { + I18NTranslation["Error"] = "error"; + I18NTranslation["Ignore"] = "ignore"; + I18NTranslation["Warning"] = "warning"; +})(I18NTranslation = exports.I18NTranslation || (exports.I18NTranslation = {})); +/** + * The stylesheet language to use for the application's inline component styles. + */ +var InlineStyleLanguage; +(function (InlineStyleLanguage) { + InlineStyleLanguage["Css"] = "css"; + InlineStyleLanguage["Less"] = "less"; + InlineStyleLanguage["Sass"] = "sass"; + InlineStyleLanguage["Scss"] = "scss"; +})(InlineStyleLanguage = exports.InlineStyleLanguage || (exports.InlineStyleLanguage = {})); +/** + * Define the output filename cache-busting hashing mode. + */ +var OutputHashing; +(function (OutputHashing) { + OutputHashing["All"] = "all"; + OutputHashing["Bundles"] = "bundles"; + OutputHashing["Media"] = "media"; + OutputHashing["None"] = "none"; +})(OutputHashing = exports.OutputHashing || (exports.OutputHashing = {})); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser/schema.ts"],"names":[],"mappings":";AACA,mFAAmF;AACnF,oFAAoF;;;AAoPpF;;GAEG;AACH,IAAY,IAQX;AARD,WAAY,IAAI;IACZ,mBAAW,CAAA;IACX,+BAAuB,CAAA;IACvB,mBAAW,CAAA;IACX,+CAAuC,CAAA;IACvC,+BAAuB,CAAA;IACvB,yBAAiB,CAAA;IACjB,2BAAmB,CAAA;AACvB,CAAC,EARW,IAAI,GAAJ,YAAI,KAAJ,YAAI,QAQf;AAED;;GAEG;AACH,IAAY,WAIX;AAJD,WAAY,WAAW;IACnB,sCAAuB,CAAA;IACvB,4BAAa,CAAA;IACb,iDAAkC,CAAA;AACtC,CAAC,EAJW,WAAW,GAAX,mBAAW,KAAX,mBAAW,QAItB;AASD;;;;GAIG;AACH,IAAY,eAIX;AAJD,WAAY,eAAe;IACvB,kCAAe,CAAA;IACf,oCAAiB,CAAA;IACjB,sCAAmB,CAAA;AACvB,CAAC,EAJW,eAAe,GAAf,uBAAe,KAAf,uBAAe,QAI1B;AAoBD;;GAEG;AACH,IAAY,mBAKX;AALD,WAAY,mBAAmB;IAC3B,kCAAW,CAAA;IACX,oCAAa,CAAA;IACb,oCAAa,CAAA;IACb,oCAAa,CAAA;AACjB,CAAC,EALW,mBAAmB,GAAnB,2BAAmB,KAAnB,2BAAmB,QAK9B;AA+DD;;GAEG;AACH,IAAY,aAKX;AALD,WAAY,aAAa;IACrB,4BAAW,CAAA;IACX,oCAAmB,CAAA;IACnB,gCAAe,CAAA;IACf,8BAAa,CAAA;AACjB,CAAC,EALW,aAAa,GAAb,qBAAa,KAAb,qBAAa,QAKxB","sourcesContent":["\n// THIS FILE IS AUTOMATICALLY GENERATED. TO UPDATE THIS FILE YOU NEED TO CHANGE THE\n// CORRESPONDING JSON SCHEMA FILE, THEN RUN devkit-admin build (or bazel build ...).\n\n/**\n * Browser target options\n */\nexport interface Schema {\n    /**\n     * A list of CommonJS packages that are allowed to be used without a build time warning.\n     */\n    allowedCommonJsDependencies?: string[];\n    /**\n     * Build using Ahead of Time compilation.\n     */\n    aot?: boolean;\n    /**\n     * List of static application assets.\n     */\n    assets?: AssetPattern[];\n    /**\n     * Base url for the application being built.\n     */\n    baseHref?: string;\n    /**\n     * Budget thresholds to ensure parts of your application stay within boundaries which you\n     * set.\n     */\n    budgets?: Budget[];\n    /**\n     * Enables advanced build optimizations when using the 'aot' option.\n     */\n    buildOptimizer?: boolean;\n    /**\n     * Generate a seperate bundle containing code used across multiple bundles.\n     */\n    commonChunk?: boolean;\n    /**\n     * Define the crossorigin attribute setting of elements that provide CORS support.\n     */\n    crossOrigin?: CrossOrigin;\n    /**\n     * Delete the output path before building.\n     */\n    deleteOutputPath?: boolean;\n    /**\n     * URL where files will be deployed.\n     * @deprecated Use \"baseHref\" option, \"APP_BASE_HREF\" DI token or a combination of both\n     * instead. For more information, see https://angular.io/guide/deployment#the-deploy-url.\n     */\n    deployUrl?: string;\n    /**\n     * Extract all licenses in a separate file.\n     */\n    extractLicenses?: boolean;\n    /**\n     * Replace compilation source files with other compilation source files in the build.\n     */\n    fileReplacements?: FileReplacement[];\n    /**\n     * How to handle duplicate translations for i18n.\n     */\n    i18nDuplicateTranslation?: I18NTranslation;\n    /**\n     * How to handle missing translations for i18n.\n     */\n    i18nMissingTranslation?: I18NTranslation;\n    /**\n     * Configures the generation of the application's HTML index.\n     */\n    index: IndexUnion;\n    /**\n     * The stylesheet language to use for the application's inline component styles.\n     */\n    inlineStyleLanguage?: InlineStyleLanguage;\n    /**\n     * Translate the bundles in one or more locales.\n     */\n    localize?: Localize;\n    /**\n     * The full path for the main entry point to the app, relative to the current workspace.\n     */\n    main: string;\n    /**\n     * Use file name for lazy loaded chunks.\n     */\n    namedChunks?: boolean;\n    /**\n     * Path to ngsw-config.json.\n     */\n    ngswConfigPath?: string;\n    /**\n     * Enables optimization of the build output. Including minification of scripts and styles,\n     * tree-shaking, dead-code elimination, inlining of critical CSS and fonts inlining. For\n     * more information, see\n     * https://angular.io/guide/workspace-config#optimization-configuration.\n     */\n    optimization?: OptimizationUnion;\n    /**\n     * Define the output filename cache-busting hashing mode.\n     */\n    outputHashing?: OutputHashing;\n    /**\n     * The full path for the new output directory, relative to the current workspace.\n     * By default, writes output to a folder named dist/ in the current project.\n     */\n    outputPath: string;\n    /**\n     * Enable and define the file watching poll time period in milliseconds.\n     */\n    poll?: number;\n    /**\n     * Polyfills to be included in the build.\n     */\n    polyfills?: Polyfills;\n    /**\n     * Do not use the real path when resolving modules. If unset then will default to `true` if\n     * NodeJS option --preserve-symlinks is set.\n     */\n    preserveSymlinks?: boolean;\n    /**\n     * Log progress to the console while building.\n     */\n    progress?: boolean;\n    /**\n     * The path where style resources will be placed, relative to outputPath.\n     */\n    resourcesOutputPath?: string;\n    /**\n     * Global scripts to be included in the build.\n     */\n    scripts?: ScriptElement[];\n    /**\n     * Generates a service worker config for production builds.\n     */\n    serviceWorker?: boolean;\n    /**\n     * Output source maps for scripts and styles. For more information, see\n     * https://angular.io/guide/workspace-config#source-map-configuration.\n     */\n    sourceMap?: SourceMapUnion;\n    /**\n     * Generates a 'stats.json' file which can be analyzed using tools such as\n     * 'webpack-bundle-analyzer'.\n     */\n    statsJson?: boolean;\n    /**\n     * Options to pass to style preprocessors.\n     */\n    stylePreprocessorOptions?: StylePreprocessorOptions;\n    /**\n     * Global styles to be included in the build.\n     */\n    styles?: StyleElement[];\n    /**\n     * Enables the use of subresource integrity validation.\n     */\n    subresourceIntegrity?: boolean;\n    /**\n     * The full path for the TypeScript configuration file, relative to the current workspace.\n     */\n    tsConfig: string;\n    /**\n     * Generate a seperate bundle containing only vendor libraries. This option should only be\n     * used for development to reduce the incremental compilation time.\n     */\n    vendorChunk?: boolean;\n    /**\n     * Adds more details to output logging.\n     */\n    verbose?: boolean;\n    /**\n     * Run build when files change.\n     */\n    watch?: boolean;\n    /**\n     * TypeScript configuration for Web Worker modules.\n     */\n    webWorkerTsConfig?: string;\n}\n\nexport type AssetPattern = AssetPatternClass | string;\n\nexport interface AssetPatternClass {\n    /**\n     * Allow glob patterns to follow symlink directories. This allows subdirectories of the\n     * symlink to be searched.\n     */\n    followSymlinks?: boolean;\n    /**\n     * The pattern to match.\n     */\n    glob: string;\n    /**\n     * An array of globs to ignore.\n     */\n    ignore?: string[];\n    /**\n     * The input directory path in which to apply 'glob'. Defaults to the project root.\n     */\n    input: string;\n    /**\n     * Absolute path within the output.\n     */\n    output: string;\n}\n\nexport interface Budget {\n    /**\n     * The baseline size for comparison.\n     */\n    baseline?: string;\n    /**\n     * The threshold for error relative to the baseline (min & max).\n     */\n    error?: string;\n    /**\n     * The maximum threshold for error relative to the baseline.\n     */\n    maximumError?: string;\n    /**\n     * The maximum threshold for warning relative to the baseline.\n     */\n    maximumWarning?: string;\n    /**\n     * The minimum threshold for error relative to the baseline.\n     */\n    minimumError?: string;\n    /**\n     * The minimum threshold for warning relative to the baseline.\n     */\n    minimumWarning?: string;\n    /**\n     * The name of the bundle.\n     */\n    name?: string;\n    /**\n     * The type of budget.\n     */\n    type: Type;\n    /**\n     * The threshold for warning relative to the baseline (min & max).\n     */\n    warning?: string;\n}\n\n/**\n * The type of budget.\n */\nexport enum Type {\n    All = \"all\",\n    AllScript = \"allScript\",\n    Any = \"any\",\n    AnyComponentStyle = \"anyComponentStyle\",\n    AnyScript = \"anyScript\",\n    Bundle = \"bundle\",\n    Initial = \"initial\",\n}\n\n/**\n * Define the crossorigin attribute setting of elements that provide CORS support.\n */\nexport enum CrossOrigin {\n    Anonymous = \"anonymous\",\n    None = \"none\",\n    UseCredentials = \"use-credentials\",\n}\n\nexport interface FileReplacement {\n    replace?:     string;\n    replaceWith?: string;\n    src?:         string;\n    with?:        string;\n}\n\n/**\n * How to handle duplicate translations for i18n.\n *\n * How to handle missing translations for i18n.\n */\nexport enum I18NTranslation {\n    Error = \"error\",\n    Ignore = \"ignore\",\n    Warning = \"warning\",\n}\n\n/**\n * Configures the generation of the application's HTML index.\n */\nexport type IndexUnion = IndexObject | string;\n\nexport interface IndexObject {\n    /**\n     * The path of a file to use for the application's generated HTML index.\n     */\n    input: string;\n    /**\n     * The output path of the application's generated HTML index file. The full provided path\n     * will be used and will be considered relative to the application's configured output path.\n     */\n    output?: string;\n    [property: string]: any;\n}\n\n/**\n * The stylesheet language to use for the application's inline component styles.\n */\nexport enum InlineStyleLanguage {\n    Css = \"css\",\n    Less = \"less\",\n    Sass = \"sass\",\n    Scss = \"scss\",\n}\n\n/**\n * Translate the bundles in one or more locales.\n */\nexport type Localize = string[] | boolean;\n\n/**\n * Enables optimization of the build output. Including minification of scripts and styles,\n * tree-shaking, dead-code elimination, inlining of critical CSS and fonts inlining. For\n * more information, see\n * https://angular.io/guide/workspace-config#optimization-configuration.\n */\nexport type OptimizationUnion = boolean | OptimizationClass;\n\nexport interface OptimizationClass {\n    /**\n     * Enables optimization for fonts. This option requires internet access. `HTTPS_PROXY`\n     * environment variable can be used to specify a proxy server.\n     */\n    fonts?: FontsUnion;\n    /**\n     * Enables optimization of the scripts output.\n     */\n    scripts?: boolean;\n    /**\n     * Enables optimization of the styles output.\n     */\n    styles?: StylesUnion;\n}\n\n/**\n * Enables optimization for fonts. This option requires internet access. `HTTPS_PROXY`\n * environment variable can be used to specify a proxy server.\n */\nexport type FontsUnion = boolean | FontsClass;\n\nexport interface FontsClass {\n    /**\n     * Reduce render blocking requests by inlining external Google Fonts and Adobe Fonts CSS\n     * definitions in the application's HTML index file. This option requires internet access.\n     * `HTTPS_PROXY` environment variable can be used to specify a proxy server.\n     */\n    inline?: boolean;\n}\n\n/**\n * Enables optimization of the styles output.\n */\nexport type StylesUnion = boolean | StylesClass;\n\nexport interface StylesClass {\n    /**\n     * Extract and inline critical CSS definitions to improve first paint time.\n     */\n    inlineCritical?: boolean;\n    /**\n     * Minify CSS definitions by removing extraneous whitespace and comments, merging\n     * identifiers and minimizing values.\n     */\n    minify?: boolean;\n}\n\n/**\n * Define the output filename cache-busting hashing mode.\n */\nexport enum OutputHashing {\n    All = \"all\",\n    Bundles = \"bundles\",\n    Media = \"media\",\n    None = \"none\",\n}\n\n/**\n * Polyfills to be included in the build.\n */\nexport type Polyfills = string[] | string;\n\nexport type ScriptElement = ScriptClass | string;\n\nexport interface ScriptClass {\n    /**\n     * The bundle name for this extra entry point.\n     */\n    bundleName?: string;\n    /**\n     * If the bundle will be referenced in the HTML file.\n     */\n    inject?: boolean;\n    /**\n     * The file to include.\n     */\n    input: string;\n}\n\n/**\n * Output source maps for scripts and styles. For more information, see\n * https://angular.io/guide/workspace-config#source-map-configuration.\n */\nexport type SourceMapUnion = boolean | SourceMapClass;\n\nexport interface SourceMapClass {\n    /**\n     * Output source maps used for error reporting tools.\n     */\n    hidden?: boolean;\n    /**\n     * Output source maps for all scripts.\n     */\n    scripts?: boolean;\n    /**\n     * Output source maps for all styles.\n     */\n    styles?: boolean;\n    /**\n     * Resolve vendor packages source maps.\n     */\n    vendor?: boolean;\n}\n\n/**\n * Options to pass to style preprocessors.\n */\nexport interface StylePreprocessorOptions {\n    /**\n     * Paths to include. Paths will be resolved to workspace root.\n     */\n    includePaths?: string[];\n}\n\nexport type StyleElement = StyleClass | string;\n\nexport interface StyleClass {\n    /**\n     * The bundle name for this extra entry point.\n     */\n    bundleName?: string;\n    /**\n     * If the bundle will be referenced in the HTML file.\n     */\n    inject?: boolean;\n    /**\n     * The file to include.\n     */\n    input: string;\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/browser/schema.json b/artifacts/build-angular/src/builders/browser/schema.json new file mode 100644 index 00000000..b45065bb --- /dev/null +++ b/artifacts/build-angular/src/builders/browser/schema.json @@ -0,0 +1,548 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema", + "title": "Webpack browser schema for Build Facade.", + "description": "Browser target options", + "type": "object", + "properties": { + "assets": { + "type": "array", + "description": "List of static application assets.", + "default": [], + "items": { + "$ref": "#/definitions/assetPattern" + } + }, + "main": { + "type": "string", + "description": "The full path for the main entry point to the app, relative to the current workspace." + }, + "polyfills": { + "description": "Polyfills to be included in the build.", + "oneOf": [ + { + "type": "array", + "description": "A list of polyfills to include in the build. Can be a full path for a file, relative to the current workspace or module specifier. Example: 'zone.js'.", + "items": { + "type": "string", + "uniqueItems": true + }, + "default": [] + }, + { + "type": "string", + "description": "The full path for the polyfills file, relative to the current workspace or a module specifier. Example: 'zone.js'." + } + ] + }, + "tsConfig": { + "type": "string", + "description": "The full path for the TypeScript configuration file, relative to the current workspace." + }, + "scripts": { + "description": "Global scripts to be included in the build.", + "type": "array", + "default": [], + "items": { + "oneOf": [ + { + "type": "object", + "properties": { + "input": { + "type": "string", + "description": "The file to include.", + "pattern": "\\.[cm]?jsx?$" + }, + "bundleName": { + "type": "string", + "pattern": "^[\\w\\-.]*$", + "description": "The bundle name for this extra entry point." + }, + "inject": { + "type": "boolean", + "description": "If the bundle will be referenced in the HTML file.", + "default": true + } + }, + "additionalProperties": false, + "required": ["input"] + }, + { + "type": "string", + "description": "The file to include.", + "pattern": "\\.[cm]?jsx?$" + } + ] + } + }, + "styles": { + "description": "Global styles to be included in the build.", + "type": "array", + "default": [], + "items": { + "oneOf": [ + { + "type": "object", + "properties": { + "input": { + "type": "string", + "description": "The file to include.", + "pattern": "\\.(?:css|scss|sass|less)$" + }, + "bundleName": { + "type": "string", + "pattern": "^[\\w\\-.]*$", + "description": "The bundle name for this extra entry point." + }, + "inject": { + "type": "boolean", + "description": "If the bundle will be referenced in the HTML file.", + "default": true + } + }, + "additionalProperties": false, + "required": ["input"] + }, + { + "type": "string", + "description": "The file to include.", + "pattern": "\\.(?:css|scss|sass|less)$" + } + ] + } + }, + "inlineStyleLanguage": { + "description": "The stylesheet language to use for the application's inline component styles.", + "type": "string", + "default": "css", + "enum": ["css", "less", "sass", "scss"] + }, + "stylePreprocessorOptions": { + "description": "Options to pass to style preprocessors.", + "type": "object", + "properties": { + "includePaths": { + "description": "Paths to include. Paths will be resolved to workspace root.", + "type": "array", + "items": { + "type": "string" + }, + "default": [] + } + }, + "additionalProperties": false + }, + "optimization": { + "description": "Enables optimization of the build output. Including minification of scripts and styles, tree-shaking, dead-code elimination, inlining of critical CSS and fonts inlining. For more information, see https://angular.io/guide/workspace-config#optimization-configuration.", + "default": true, + "x-user-analytics": "ep.ng_optimization", + "oneOf": [ + { + "type": "object", + "properties": { + "scripts": { + "type": "boolean", + "description": "Enables optimization of the scripts output.", + "default": true + }, + "styles": { + "description": "Enables optimization of the styles output.", + "default": true, + "oneOf": [ + { + "type": "object", + "properties": { + "minify": { + "type": "boolean", + "description": "Minify CSS definitions by removing extraneous whitespace and comments, merging identifiers and minimizing values.", + "default": true + }, + "inlineCritical": { + "type": "boolean", + "description": "Extract and inline critical CSS definitions to improve first paint time.", + "default": true + } + }, + "additionalProperties": false + }, + { + "type": "boolean" + } + ] + }, + "fonts": { + "description": "Enables optimization for fonts. This option requires internet access. `HTTPS_PROXY` environment variable can be used to specify a proxy server.", + "default": true, + "oneOf": [ + { + "type": "object", + "properties": { + "inline": { + "type": "boolean", + "description": "Reduce render blocking requests by inlining external Google Fonts and Adobe Fonts CSS definitions in the application's HTML index file. This option requires internet access. `HTTPS_PROXY` environment variable can be used to specify a proxy server.", + "default": true + } + }, + "additionalProperties": false + }, + { + "type": "boolean" + } + ] + } + }, + "additionalProperties": false + }, + { + "type": "boolean" + } + ] + }, + "fileReplacements": { + "description": "Replace compilation source files with other compilation source files in the build.", + "type": "array", + "items": { + "$ref": "#/definitions/fileReplacement" + }, + "default": [] + }, + "outputPath": { + "type": "string", + "description": "The full path for the new output directory, relative to the current workspace.\nBy default, writes output to a folder named dist/ in the current project." + }, + "resourcesOutputPath": { + "type": "string", + "description": "The path where style resources will be placed, relative to outputPath." + }, + "aot": { + "type": "boolean", + "description": "Build using Ahead of Time compilation.", + "x-user-analytics": "ep.ng_aot", + "default": true + }, + "sourceMap": { + "description": "Output source maps for scripts and styles. For more information, see https://angular.io/guide/workspace-config#source-map-configuration.", + "default": false, + "oneOf": [ + { + "type": "object", + "properties": { + "scripts": { + "type": "boolean", + "description": "Output source maps for all scripts.", + "default": true + }, + "styles": { + "type": "boolean", + "description": "Output source maps for all styles.", + "default": true + }, + "hidden": { + "type": "boolean", + "description": "Output source maps used for error reporting tools.", + "default": false + }, + "vendor": { + "type": "boolean", + "description": "Resolve vendor packages source maps.", + "default": false + } + }, + "additionalProperties": false + }, + { + "type": "boolean" + } + ] + }, + "vendorChunk": { + "type": "boolean", + "description": "Generate a seperate bundle containing only vendor libraries. This option should only be used for development to reduce the incremental compilation time.", + "default": false + }, + "commonChunk": { + "type": "boolean", + "description": "Generate a seperate bundle containing code used across multiple bundles.", + "default": true + }, + "baseHref": { + "type": "string", + "description": "Base url for the application being built." + }, + "deployUrl": { + "type": "string", + "description": "URL where files will be deployed.", + "x-deprecated": "Use \"baseHref\" option, \"APP_BASE_HREF\" DI token or a combination of both instead. For more information, see https://angular.io/guide/deployment#the-deploy-url." + }, + "verbose": { + "type": "boolean", + "description": "Adds more details to output logging.", + "default": false + }, + "progress": { + "type": "boolean", + "description": "Log progress to the console while building.", + "default": true + }, + "i18nMissingTranslation": { + "type": "string", + "description": "How to handle missing translations for i18n.", + "enum": ["warning", "error", "ignore"], + "default": "warning" + }, + "i18nDuplicateTranslation": { + "type": "string", + "description": "How to handle duplicate translations for i18n.", + "enum": ["warning", "error", "ignore"], + "default": "warning" + }, + "localize": { + "description": "Translate the bundles in one or more locales.", + "oneOf": [ + { + "type": "boolean", + "description": "Translate all locales." + }, + { + "type": "array", + "description": "List of locales ID's to translate.", + "minItems": 1, + "items": { + "type": "string", + "pattern": "^[a-zA-Z]{2,3}(-[a-zA-Z]{4})?(-([a-zA-Z]{2}|[0-9]{3}))?(-[a-zA-Z]{5,8})?(-x(-[a-zA-Z0-9]{1,8})+)?$" + } + } + ] + }, + "watch": { + "type": "boolean", + "description": "Run build when files change.", + "default": false + }, + "outputHashing": { + "type": "string", + "description": "Define the output filename cache-busting hashing mode.", + "default": "none", + "enum": ["none", "all", "media", "bundles"] + }, + "poll": { + "type": "number", + "description": "Enable and define the file watching poll time period in milliseconds." + }, + "deleteOutputPath": { + "type": "boolean", + "description": "Delete the output path before building.", + "default": true + }, + "preserveSymlinks": { + "type": "boolean", + "description": "Do not use the real path when resolving modules. If unset then will default to `true` if NodeJS option --preserve-symlinks is set." + }, + "extractLicenses": { + "type": "boolean", + "description": "Extract all licenses in a separate file.", + "default": true + }, + "buildOptimizer": { + "type": "boolean", + "description": "Enables advanced build optimizations when using the 'aot' option.", + "default": true + }, + "namedChunks": { + "type": "boolean", + "description": "Use file name for lazy loaded chunks.", + "default": false + }, + "subresourceIntegrity": { + "type": "boolean", + "description": "Enables the use of subresource integrity validation.", + "default": false + }, + "serviceWorker": { + "type": "boolean", + "description": "Generates a service worker config for production builds.", + "default": false + }, + "ngswConfigPath": { + "type": "string", + "description": "Path to ngsw-config.json." + }, + "index": { + "description": "Configures the generation of the application's HTML index.", + "oneOf": [ + { + "type": "string", + "description": "The path of a file to use for the application's HTML index. The filename of the specified path will be used for the generated file and will be created in the root of the application's configured output path." + }, + { + "type": "object", + "description": "", + "properties": { + "input": { + "type": "string", + "minLength": 1, + "description": "The path of a file to use for the application's generated HTML index." + }, + "output": { + "type": "string", + "minLength": 1, + "default": "index.html", + "description": "The output path of the application's generated HTML index file. The full provided path will be used and will be considered relative to the application's configured output path." + } + }, + "required": ["input"] + } + ] + }, + "statsJson": { + "type": "boolean", + "description": "Generates a 'stats.json' file which can be analyzed using tools such as 'webpack-bundle-analyzer'.", + "default": false + }, + "budgets": { + "description": "Budget thresholds to ensure parts of your application stay within boundaries which you set.", + "type": "array", + "items": { + "$ref": "#/definitions/budget" + }, + "default": [] + }, + "webWorkerTsConfig": { + "type": "string", + "description": "TypeScript configuration for Web Worker modules." + }, + "crossOrigin": { + "type": "string", + "description": "Define the crossorigin attribute setting of elements that provide CORS support.", + "default": "none", + "enum": ["none", "anonymous", "use-credentials"] + }, + "allowedCommonJsDependencies": { + "description": "A list of CommonJS packages that are allowed to be used without a build time warning.", + "type": "array", + "items": { + "type": "string" + }, + "default": [] + } + }, + "additionalProperties": false, + "required": ["outputPath", "index", "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": [ + { + "type": "object", + "properties": { + "src": { + "type": "string", + "pattern": "\\.(([cm]?j|t)sx?|json)$" + }, + "replaceWith": { + "type": "string", + "pattern": "\\.(([cm]?j|t)sx?|json)$" + } + }, + "additionalProperties": false, + "required": ["src", "replaceWith"] + }, + { + "type": "object", + "properties": { + "replace": { + "type": "string", + "pattern": "\\.(([cm]?j|t)sx?|json)$" + }, + "with": { + "type": "string", + "pattern": "\\.(([cm]?j|t)sx?|json)$" + } + }, + "additionalProperties": false, + "required": ["replace", "with"] + } + ] + }, + "budget": { + "type": "object", + "properties": { + "type": { + "type": "string", + "description": "The type of budget.", + "enum": ["all", "allScript", "any", "anyScript", "anyComponentStyle", "bundle", "initial"] + }, + "name": { + "type": "string", + "description": "The name of the bundle." + }, + "baseline": { + "type": "string", + "description": "The baseline size for comparison." + }, + "maximumWarning": { + "type": "string", + "description": "The maximum threshold for warning relative to the baseline." + }, + "maximumError": { + "type": "string", + "description": "The maximum threshold for error relative to the baseline." + }, + "minimumWarning": { + "type": "string", + "description": "The minimum threshold for warning relative to the baseline." + }, + "minimumError": { + "type": "string", + "description": "The minimum threshold for error relative to the baseline." + }, + "warning": { + "type": "string", + "description": "The threshold for warning relative to the baseline (min & max)." + }, + "error": { + "type": "string", + "description": "The threshold for error relative to the baseline (min & max)." + } + }, + "additionalProperties": false, + "required": ["type"] + } + } +} diff --git a/artifacts/build-angular/src/builders/dev-server/builder.d.ts b/artifacts/build-angular/src/builders/dev-server/builder.d.ts new file mode 100644 index 00000000..5d4a9d53 --- /dev/null +++ b/artifacts/build-angular/src/builders/dev-server/builder.d.ts @@ -0,0 +1,27 @@ +/** + * @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 type { BuilderContext } from '@angular-devkit/architect'; +import { Observable } from 'rxjs'; +import type { ExecutionTransformer } from '../../transforms'; +import type { IndexHtmlTransform } from '../../utils/index-file/index-html-generator'; +import type { Schema as DevServerBuilderOptions } from './schema'; +import type { DevServerBuilderOutput } from './webpack-server'; +/** + * A Builder that executes a development server based on the provided browser target option. + * @param options Dev Server options. + * @param context The build context. + * @param transforms A map of transforms that can be used to hook into some logic (such as + * transforming webpack configuration before passing it to webpack). + * + * @experimental Direct usage of this function is considered experimental. + */ +export declare function execute(options: DevServerBuilderOptions, context: BuilderContext, transforms?: { + webpackConfiguration?: ExecutionTransformer; + logging?: import('@angular-devkit/build-webpack').WebpackLoggingCallback; + indexHtml?: IndexHtmlTransform; +}): Observable; diff --git a/artifacts/build-angular/src/builders/dev-server/builder.js b/artifacts/build-angular/src/builders/dev-server/builder.js new file mode 100644 index 00000000..9ab1a414 --- /dev/null +++ b/artifacts/build-angular/src/builders/dev-server/builder.js @@ -0,0 +1,89 @@ +"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.execute = void 0; +const rxjs_1 = require("rxjs"); +const check_port_1 = require("../../utils/check-port"); +const purge_cache_1 = require("../../utils/purge-cache"); +const options_1 = require("./options"); +/** + * A Builder that executes a development server based on the provided browser target option. + * @param options Dev Server options. + * @param context The build context. + * @param transforms A map of transforms that can be used to hook into some logic (such as + * transforming webpack configuration before passing it to webpack). + * + * @experimental Direct usage of this function is considered experimental. + */ +function execute(options, context, transforms = {}) { + // Determine project name from builder context target + const projectName = context.target?.project; + if (!projectName) { + context.logger.error(`The 'dev-server' builder requires a target to be specified.`); + return rxjs_1.EMPTY; + } + return (0, rxjs_1.defer)(() => initialize(options, projectName, context)).pipe((0, rxjs_1.switchMap)(({ builderName, normalizedOptions }) => { + // Use vite-based development server for esbuild-based builds + if (builderName === '@angular-devkit/build-angular:browser-esbuild') { + return (0, rxjs_1.defer)(() => Promise.resolve().then(() => __importStar(require('./vite-server')))).pipe((0, rxjs_1.switchMap)(({ serveWithVite }) => serveWithVite(normalizedOptions, builderName, context))); + } + // Use Webpack for all other browser targets + return (0, rxjs_1.defer)(() => Promise.resolve().then(() => __importStar(require('./webpack-server')))).pipe((0, rxjs_1.switchMap)(({ serveWebpackBrowser }) => serveWebpackBrowser(normalizedOptions, builderName, context, transforms))); + })); +} +exports.execute = execute; +async function initialize(initialOptions, projectName, context) { + // Purge old build disk cache. + await (0, purge_cache_1.purgeStaleBuildCache)(context); + const normalizedOptions = await (0, options_1.normalizeOptions)(context, projectName, initialOptions); + const builderName = await context.getBuilderNameForTarget(normalizedOptions.browserTarget); + if (!normalizedOptions.disableHostCheck && + !/^127\.\d+\.\d+\.\d+/g.test(normalizedOptions.host) && + normalizedOptions.host !== 'localhost') { + context.logger.warn(` +Warning: This is a simple server for use in testing or debugging Angular applications +locally. It hasn't been reviewed for security issues. + +Binding this server to an open connection can result in compromising your application or +computer. Using a different host than the one passed to the "--host" flag might result in +websocket connection issues. You might need to use "--disable-host-check" if that's the +case. + `); + } + if (normalizedOptions.disableHostCheck) { + context.logger.warn('Warning: Running a server with --disable-host-check is a security risk. ' + + 'See https://medium.com/webpack/webpack-dev-server-middleware-security-issues-1489d950874a for more information.'); + } + normalizedOptions.port = await (0, check_port_1.checkPort)(normalizedOptions.port, normalizedOptions.host); + return { builderName, normalizedOptions }; +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/dev-server/index.d.ts b/artifacts/build-angular/src/builders/dev-server/index.d.ts new file mode 100644 index 00000000..065dd28e --- /dev/null +++ b/artifacts/build-angular/src/builders/dev-server/index.d.ts @@ -0,0 +1,14 @@ +/** + * @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 { execute } from './builder'; +import { Schema as DevServerBuilderOptions } from './schema'; +import { DevServerBuilderOutput } from './webpack-server'; +export { DevServerBuilderOptions, DevServerBuilderOutput, execute as executeDevServerBuilder }; +declare const _default: import("../../../../architect/src/internal").Builder; +export default _default; +export { execute as serveWebpackBrowser }; diff --git a/artifacts/build-angular/src/builders/dev-server/index.js b/artifacts/build-angular/src/builders/dev-server/index.js new file mode 100644 index 00000000..64be4ac4 --- /dev/null +++ b/artifacts/build-angular/src/builders/dev-server/index.js @@ -0,0 +1,16 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.serveWebpackBrowser = exports.executeDevServerBuilder = void 0; +const architect_1 = require("@angular-devkit/architect"); +const builder_1 = require("./builder"); +Object.defineProperty(exports, "executeDevServerBuilder", { enumerable: true, get: function () { return builder_1.execute; } }); +Object.defineProperty(exports, "serveWebpackBrowser", { enumerable: true, get: function () { return builder_1.execute; } }); +exports.default = (0, architect_1.createBuilder)(builder_1.execute); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9hbmd1bGFyX2RldmtpdC9idWlsZF9hbmd1bGFyL3NyYy9idWlsZGVycy9kZXYtc2VydmVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7O0dBTUc7OztBQUVILHlEQUEwRDtBQUMxRCx1Q0FBb0M7QUFJaUMsd0dBSjVELGlCQUFPLE9BSTRFO0FBSXhFLG9HQVJYLGlCQUFPLE9BUXVCO0FBSHZDLGtCQUFlLElBQUEseUJBQWEsRUFBa0QsaUJBQU8sQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCB7IGNyZWF0ZUJ1aWxkZXIgfSBmcm9tICdAYW5ndWxhci1kZXZraXQvYXJjaGl0ZWN0JztcbmltcG9ydCB7IGV4ZWN1dGUgfSBmcm9tICcuL2J1aWxkZXInO1xuaW1wb3J0IHsgU2NoZW1hIGFzIERldlNlcnZlckJ1aWxkZXJPcHRpb25zIH0gZnJvbSAnLi9zY2hlbWEnO1xuaW1wb3J0IHsgRGV2U2VydmVyQnVpbGRlck91dHB1dCB9IGZyb20gJy4vd2VicGFjay1zZXJ2ZXInO1xuXG5leHBvcnQgeyBEZXZTZXJ2ZXJCdWlsZGVyT3B0aW9ucywgRGV2U2VydmVyQnVpbGRlck91dHB1dCwgZXhlY3V0ZSBhcyBleGVjdXRlRGV2U2VydmVyQnVpbGRlciB9O1xuZXhwb3J0IGRlZmF1bHQgY3JlYXRlQnVpbGRlcjxEZXZTZXJ2ZXJCdWlsZGVyT3B0aW9ucywgRGV2U2VydmVyQnVpbGRlck91dHB1dD4oZXhlY3V0ZSk7XG5cbi8vIFRlbXBvcmFyeSBleHBvcnQgdG8gc3VwcG9ydCBzcGVjc1xuZXhwb3J0IHsgZXhlY3V0ZSBhcyBzZXJ2ZVdlYnBhY2tCcm93c2VyIH07XG4iXX0= \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/dev-server/load-proxy-config.d.ts b/artifacts/build-angular/src/builders/dev-server/load-proxy-config.d.ts new file mode 100644 index 00000000..b74f5b81 --- /dev/null +++ b/artifacts/build-angular/src/builders/dev-server/load-proxy-config.d.ts @@ -0,0 +1,8 @@ +/** + * @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 + */ +export declare function loadProxyConfiguration(root: string, proxyConfig: string | undefined): Promise; diff --git a/artifacts/build-angular/src/builders/dev-server/load-proxy-config.js b/artifacts/build-angular/src/builders/dev-server/load-proxy-config.js new file mode 100644 index 00000000..0c6baf2f --- /dev/null +++ b/artifacts/build-angular/src/builders/dev-server/load-proxy-config.js @@ -0,0 +1,113 @@ +"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.loadProxyConfiguration = void 0; +const node_fs_1 = require("node:fs"); +const promises_1 = require("node:fs/promises"); +const node_path_1 = require("node:path"); +const node_url_1 = require("node:url"); +const error_1 = require("../../utils/error"); +const load_esm_1 = require("../../utils/load-esm"); +async function loadProxyConfiguration(root, proxyConfig) { + if (!proxyConfig) { + return undefined; + } + const proxyPath = (0, node_path_1.resolve)(root, proxyConfig); + if (!(0, node_fs_1.existsSync)(proxyPath)) { + throw new Error(`Proxy configuration file ${proxyPath} does not exist.`); + } + switch ((0, node_path_1.extname)(proxyPath)) { + case '.json': { + const content = await (0, promises_1.readFile)(proxyPath, 'utf-8'); + const { parse, printParseErrorCode } = await Promise.resolve().then(() => __importStar(require('jsonc-parser'))); + const parseErrors = []; + const proxyConfiguration = parse(content, parseErrors, { allowTrailingComma: true }); + if (parseErrors.length > 0) { + let errorMessage = `Proxy configuration file ${proxyPath} contains parse errors:`; + for (const parseError of parseErrors) { + const { line, column } = getJsonErrorLineColumn(parseError.offset, content); + errorMessage += `\n[${line}, ${column}] ${printParseErrorCode(parseError.error)}`; + } + throw new Error(errorMessage); + } + return proxyConfiguration; + } + case '.mjs': + // Load the ESM configuration file using the TypeScript dynamic import workaround. + // Once TypeScript provides support for keeping the dynamic import this workaround can be + // changed to a direct dynamic import. + return (await (0, load_esm_1.loadEsmModule)((0, node_url_1.pathToFileURL)(proxyPath))).default; + case '.cjs': + return require(proxyPath); + default: + // The file could be either CommonJS or ESM. + // CommonJS is tried first then ESM if loading fails. + try { + return require(proxyPath); + } + catch (e) { + (0, error_1.assertIsError)(e); + if (e.code === 'ERR_REQUIRE_ESM') { + // Load the ESM configuration file using the TypeScript dynamic import workaround. + // Once TypeScript provides support for keeping the dynamic import this workaround can be + // changed to a direct dynamic import. + return (await (0, load_esm_1.loadEsmModule)((0, node_url_1.pathToFileURL)(proxyPath))).default; + } + throw e; + } + } +} +exports.loadProxyConfiguration = loadProxyConfiguration; +/** + * Calculates the line and column for an error offset in the content of a JSON file. + * @param location The offset error location from the beginning of the content. + * @param content The full content of the file containing the error. + * @returns An object containing the line and column + */ +function getJsonErrorLineColumn(offset, content) { + if (offset === 0) { + return { line: 1, column: 1 }; + } + let line = 0; + let position = 0; + // eslint-disable-next-line no-constant-condition + while (true) { + ++line; + const nextNewline = content.indexOf('\n', position); + if (nextNewline === -1 || nextNewline > offset) { + break; + } + position = nextNewline + 1; + } + return { line, column: offset - position + 1 }; +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/dev-server/options.d.ts b/artifacts/build-angular/src/builders/dev-server/options.d.ts new file mode 100644 index 00000000..4c3d2687 --- /dev/null +++ b/artifacts/build-angular/src/builders/dev-server/options.d.ts @@ -0,0 +1,45 @@ +/** + * @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 { Schema as DevServerOptions } from './schema'; +export type NormalizedDevServerOptions = Awaited>; +/** + * Normalize the user provided options by creating full paths for all path based options + * and converting multi-form options into a single form that can be directly used + * by the build process. + * + * @param context The context for current builder execution. + * @param projectName The name of the project for the current execution. + * @param options An object containing the options to use for the build. + * @returns An object containing normalized options required to perform the build. + */ +export declare function normalizeOptions(context: BuilderContext, projectName: string, options: DevServerOptions): Promise<{ + browserTarget: import("@angular-devkit/architect").Target; + host: string; + port: number; + poll: number | undefined; + open: boolean | undefined; + verbose: boolean | undefined; + watch: boolean | undefined; + liveReload: boolean | undefined; + hmr: boolean | undefined; + headers: { + [key: string]: string; + } | undefined; + workspaceRoot: string; + projectRoot: string; + cacheOptions: import("../../utils/normalize-cache").NormalizedCachedOptions; + allowedHosts: string[] | undefined; + disableHostCheck: boolean | undefined; + proxyConfig: string | undefined; + servePath: string | undefined; + publicHost: string | undefined; + ssl: boolean | undefined; + sslCert: string | undefined; + sslKey: string | undefined; +}>; diff --git a/artifacts/build-angular/src/builders/dev-server/options.js b/artifacts/build-angular/src/builders/dev-server/options.js new file mode 100644 index 00000000..a93926a4 --- /dev/null +++ b/artifacts/build-angular/src/builders/dev-server/options.js @@ -0,0 +1,61 @@ +"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 __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.normalizeOptions = void 0; +const architect_1 = require("@angular-devkit/architect"); +const node_path_1 = __importDefault(require("node:path")); +const normalize_cache_1 = require("../../utils/normalize-cache"); +/** + * Normalize the user provided options by creating full paths for all path based options + * and converting multi-form options into a single form that can be directly used + * by the build process. + * + * @param context The context for current builder execution. + * @param projectName The name of the project for the current execution. + * @param options An object containing the options to use for the build. + * @returns An object containing normalized options required to perform the build. + */ +async function normalizeOptions(context, projectName, options) { + const workspaceRoot = context.workspaceRoot; + const projectMetadata = await context.getProjectMetadata(projectName); + const projectRoot = node_path_1.default.join(workspaceRoot, projectMetadata.root ?? ''); + const cacheOptions = (0, normalize_cache_1.normalizeCacheOptions)(projectMetadata, workspaceRoot); + const browserTarget = (0, architect_1.targetFromTargetString)(options.browserTarget); + // Initial options to keep + const { host, port, poll, open, verbose, watch, allowedHosts, disableHostCheck, liveReload, hmr, headers, proxyConfig, servePath, publicHost, ssl, sslCert, sslKey, } = options; + // Return all the normalized options + return { + browserTarget, + host: host ?? 'localhost', + port: port ?? 4200, + poll, + open, + verbose, + watch, + liveReload, + hmr, + headers, + workspaceRoot, + projectRoot, + cacheOptions, + allowedHosts, + disableHostCheck, + proxyConfig, + servePath, + publicHost, + ssl, + sslCert, + sslKey, + }; +} +exports.normalizeOptions = normalizeOptions; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/dev-server/schema.d.ts b/artifacts/build-angular/src/builders/dev-server/schema.d.ts new file mode 100644 index 00000000..2a37433b --- /dev/null +++ b/artifacts/build-angular/src/builders/dev-server/schema.d.ts @@ -0,0 +1,84 @@ +/** + * Dev Server target options for Build Facade. + */ +export interface Schema { + /** + * List of hosts that are allowed to access the dev server. + */ + allowedHosts?: string[]; + /** + * A browser builder target to serve in the format of `project:target[:configuration]`. You + * can also pass in more than one configuration name as a comma-separated list. Example: + * `project:target:production,staging`. + */ + browserTarget: string; + /** + * Don't verify connected clients are part of allowed hosts. + */ + disableHostCheck?: boolean; + /** + * Custom HTTP headers to be added to all responses. + */ + headers?: { + [key: string]: string; + }; + /** + * Enable hot module replacement. + */ + hmr?: boolean; + /** + * Host to listen on. + */ + host?: string; + /** + * Whether to reload the page on change, using live-reload. + */ + liveReload?: boolean; + /** + * Opens the url in default browser. + */ + open?: boolean; + /** + * Enable and define the file watching poll time period in milliseconds. + */ + poll?: number; + /** + * Port to listen on. + */ + port?: number; + /** + * Proxy configuration file. For more information, see + * https://angular.io/guide/build#proxying-to-a-backend-server. + */ + proxyConfig?: string; + /** + * The URL that the browser client (or live-reload client, if enabled) should use to connect + * to the development server. Use for a complex dev server setup, such as one with reverse + * proxies. + */ + publicHost?: string; + /** + * The pathname where the application will be served. + */ + servePath?: 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; +} diff --git a/artifacts/build-angular/src/builders/dev-server/schema.js b/artifacts/build-angular/src/builders/dev-server/schema.js new file mode 100644 index 00000000..4607672a --- /dev/null +++ b/artifacts/build-angular/src/builders/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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 \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/dev-server/schema.json b/artifacts/build-angular/src/builders/dev-server/schema.json new file mode 100644 index 00000000..58bc9f68 --- /dev/null +++ b/artifacts/build-angular/src/builders/dev-server/schema.json @@ -0,0 +1,102 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema", + "title": "Dev Server Target", + "description": "Dev Server target options for Build Facade.", + "type": "object", + "properties": { + "browserTarget": { + "type": "string", + "description": "A browser builder target to serve in the format of `project:target[:configuration]`. You can also pass in more than one configuration name as a comma-separated list. Example: `project:target:production,staging`.", + "pattern": "^[^:\\s]+:[^:\\s]+(:[^\\s]+)?$" + }, + "port": { + "type": "number", + "description": "Port to listen on.", + "default": 4200 + }, + "host": { + "type": "string", + "description": "Host to listen on.", + "default": "localhost" + }, + "proxyConfig": { + "type": "string", + "description": "Proxy configuration file. For more information, see https://angular.io/guide/build#proxying-to-a-backend-server." + }, + "ssl": { + "type": "boolean", + "description": "Serve using HTTPS.", + "default": false + }, + "sslKey": { + "type": "string", + "description": "SSL key to use for serving HTTPS." + }, + "sslCert": { + "type": "string", + "description": "SSL certificate to use for serving HTTPS." + }, + "headers": { + "type": "object", + "description": "Custom HTTP headers to be added to all responses.", + "propertyNames": { + "pattern": "^[-_A-Za-z0-9]+$" + }, + "additionalProperties": { + "type": "string" + } + }, + "open": { + "type": "boolean", + "description": "Opens the url in default browser.", + "default": false, + "alias": "o" + }, + "verbose": { + "type": "boolean", + "description": "Adds more details to output logging." + }, + "liveReload": { + "type": "boolean", + "description": "Whether to reload the page on change, using live-reload.", + "default": true + }, + "publicHost": { + "type": "string", + "description": "The URL that the browser client (or live-reload client, if enabled) should use to connect to the development server. Use for a complex dev server setup, such as one with reverse proxies." + }, + "allowedHosts": { + "type": "array", + "description": "List of hosts that are allowed to access the dev server.", + "default": [], + "items": { + "type": "string" + } + }, + "servePath": { + "type": "string", + "description": "The pathname where the application will be served." + }, + "disableHostCheck": { + "type": "boolean", + "description": "Don't verify connected clients are part of allowed hosts.", + "default": false + }, + "hmr": { + "type": "boolean", + "description": "Enable hot module replacement.", + "default": false + }, + "watch": { + "type": "boolean", + "description": "Rebuild on change.", + "default": true + }, + "poll": { + "type": "number", + "description": "Enable and define the file watching poll time period in milliseconds." + } + }, + "additionalProperties": false, + "required": ["browserTarget"] +} diff --git a/artifacts/build-angular/src/builders/dev-server/vite-server.d.ts b/artifacts/build-angular/src/builders/dev-server/vite-server.d.ts new file mode 100644 index 00000000..b854ed12 --- /dev/null +++ b/artifacts/build-angular/src/builders/dev-server/vite-server.d.ts @@ -0,0 +1,21 @@ +/** + * @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 type { BuilderContext } from '@angular-devkit/architect'; +import { InlineConfig } from 'vite'; +import type { NormalizedDevServerOptions } from './options'; +import type { DevServerBuilderOutput } from './webpack-server'; +interface OutputFileRecord { + contents: Uint8Array; + size: number; + hash?: Buffer; + updated: boolean; +} +export declare function serveWithVite(serverOptions: NormalizedDevServerOptions, builderName: string, context: BuilderContext): AsyncIterableIterator; +export declare function setupServer(serverOptions: NormalizedDevServerOptions, outputFiles: Map, assets: Map): Promise; +export {}; diff --git a/artifacts/build-angular/src/builders/dev-server/vite-server.js b/artifacts/build-angular/src/builders/dev-server/vite-server.js new file mode 100644 index 00000000..b5023368 --- /dev/null +++ b/artifacts/build-angular/src/builders/dev-server/vite-server.js @@ -0,0 +1,307 @@ +"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; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.setupServer = exports.serveWithVite = void 0; +const mrmime_1 = require("mrmime"); +const node_assert_1 = __importDefault(require("node:assert")); +const node_crypto_1 = require("node:crypto"); +const promises_1 = require("node:fs/promises"); +const node_path_1 = __importDefault(require("node:path")); +const vite_1 = require("vite"); +const browser_esbuild_1 = require("../browser-esbuild"); +const load_proxy_config_1 = require("./load-proxy-config"); +function hashContent(contents) { + // TODO: Consider xxhash + return (0, node_crypto_1.createHash)('sha256').update(contents).digest(); +} +async function* serveWithVite(serverOptions, builderName, context) { + // Get the browser configuration from the target name. + const rawBrowserOptions = (await context.getTargetOptions(serverOptions.browserTarget)); + const browserOptions = (await context.validateOptions({ + ...rawBrowserOptions, + watch: serverOptions.watch, + poll: serverOptions.poll, + verbose: serverOptions.verbose, + }, builderName)); + if (serverOptions.servePath === undefined && browserOptions.baseHref !== undefined) { + serverOptions.servePath = browserOptions.baseHref; + } + let server; + let listeningAddress; + const generatedFiles = new Map(); + const assetFiles = new Map(); + // TODO: Switch this to an architect schedule call when infrastructure settings are supported + for await (const result of (0, browser_esbuild_1.buildEsbuildBrowser)(browserOptions, context, { write: false })) { + (0, node_assert_1.default)(result.outputFiles, 'Builder did not provide result files.'); + // Analyze result files for changes + analyzeResultFiles(result.outputFiles, generatedFiles); + assetFiles.clear(); + if (result.assetFiles) { + for (const asset of result.assetFiles) { + assetFiles.set('/' + (0, vite_1.normalizePath)(asset.destination), asset.source); + } + } + if (server) { + // Invalidate any updated files + for (const [file, record] of generatedFiles) { + if (record.updated) { + const updatedModules = server.moduleGraph.getModulesByFile(file); + updatedModules?.forEach((m) => server?.moduleGraph.invalidateModule(m)); + } + } + // Send reload command to clients + if (serverOptions.liveReload) { + context.logger.info('Reloading client(s)...'); + server.ws.send({ + type: 'full-reload', + path: '*', + }); + } + } + else { + // Setup server and start listening + const serverConfiguration = await setupServer(serverOptions, generatedFiles, assetFiles); + server = await (0, vite_1.createServer)(serverConfiguration); + await server.listen(); + listeningAddress = server.httpServer?.address(); + // log connection information + server.printUrls(); + } + // TODO: adjust output typings to reflect both development servers + yield { success: true, port: listeningAddress?.port }; + } + if (server) { + let deferred; + context.addTeardown(async () => { + await server?.close(); + deferred?.(); + }); + await new Promise((resolve) => (deferred = resolve)); + } +} +exports.serveWithVite = serveWithVite; +function analyzeResultFiles(resultFiles, generatedFiles) { + const seen = new Set(['/index.html']); + for (const file of resultFiles) { + const filePath = '/' + (0, vite_1.normalizePath)(file.path); + seen.add(filePath); + // Skip analysis of sourcemaps + if (filePath.endsWith('.map')) { + generatedFiles.set(filePath, { + contents: file.contents, + size: file.contents.byteLength, + updated: false, + }); + continue; + } + let fileHash; + const existingRecord = generatedFiles.get(filePath); + if (existingRecord && existingRecord.size === file.contents.byteLength) { + // Only hash existing file when needed + if (existingRecord.hash === undefined) { + existingRecord.hash = hashContent(existingRecord.contents); + } + // Compare against latest result output + fileHash = hashContent(file.contents); + if (fileHash.equals(existingRecord.hash)) { + // Same file + existingRecord.updated = false; + continue; + } + } + generatedFiles.set(filePath, { + contents: file.contents, + size: file.contents.byteLength, + hash: fileHash, + updated: true, + }); + } + // Clear stale output files + for (const file of generatedFiles.keys()) { + if (!seen.has(file)) { + generatedFiles.delete(file); + } + } +} +async function setupServer(serverOptions, outputFiles, assets) { + const proxy = await (0, load_proxy_config_1.loadProxyConfiguration)(serverOptions.workspaceRoot, serverOptions.proxyConfig); + const configuration = { + configFile: false, + envFile: false, + cacheDir: node_path_1.default.join(serverOptions.cacheOptions.path, 'vite'), + root: serverOptions.workspaceRoot, + publicDir: false, + esbuild: false, + mode: 'development', + appType: 'spa', + css: { + devSourcemap: true, + }, + base: serverOptions.servePath, + server: { + port: serverOptions.port, + strictPort: true, + host: serverOptions.host, + open: serverOptions.open, + headers: serverOptions.headers, + proxy, + // Currently does not appear to be a way to disable file watching directly so ignore all files + watch: { + ignored: ['**/*'], + }, + }, + plugins: [ + { + name: 'vite:angular-memory', + // Ensures plugin hooks run before built-in Vite hooks + enforce: 'pre', + async resolveId(source, importer) { + if (importer && source.startsWith('.')) { + // Remove query if present + const [importerFile] = importer.split('?', 1); + source = (0, vite_1.normalizePath)(node_path_1.default.join(node_path_1.default.dirname(importerFile), source)); + } + const [file] = source.split('?', 1); + if (outputFiles.has(file)) { + return source; + } + }, + load(id) { + const [file] = id.split('?', 1); + const codeContents = outputFiles.get(file)?.contents; + if (codeContents === undefined) { + return; + } + const mapContents = outputFiles.get(file + '.map')?.contents; + return { + // Remove source map URL comments from the code if a sourcemap is present. + // Vite will inline and add an additional sourcemap URL for the sourcemap. + code: Buffer.from(codeContents).toString('utf-8'), + map: mapContents && Buffer.from(mapContents).toString('utf-8'), + }; + }, + configureServer(server) { + // Assets and resources get handled first + server.middlewares.use(function angularAssetsMiddleware(req, res, next) { + if (req.url === undefined || res.writableEnded) { + return; + } + // Parse the incoming request. + // The base of the URL is unused but required to parse the URL. + const parsedUrl = new URL(req.url, 'http://localhost'); + let pathname = parsedUrl.pathname; + if (serverOptions.servePath && pathname.startsWith(serverOptions.servePath)) { + pathname = pathname.slice(serverOptions.servePath.length); + if (pathname[0] !== '/') { + pathname = '/' + pathname; + } + } + const extension = node_path_1.default.extname(pathname); + // Rewrite all build assets to a vite raw fs URL + const assetSourcePath = assets.get(pathname); + if (assetSourcePath !== undefined) { + req.url = `/@fs/${assetSourcePath}`; + next(); + return; + } + // Resource files are handled directly. + // Global stylesheets (CSS files) are currently considered resources to workaround + // dev server sourcemap issues with stylesheets. + if (extension !== '.html') { + const outputFile = outputFiles.get(pathname); + if (outputFile) { + const mimeType = (0, mrmime_1.lookup)(extension); + if (mimeType) { + res.setHeader('Content-Type', mimeType); + } + res.setHeader('Cache-Control', 'no-cache'); + if (serverOptions.headers) { + Object.entries(serverOptions.headers).forEach(([name, value]) => res.setHeader(name, value)); + } + res.end(outputFile.contents); + return; + } + } + next(); + }); + // Returning a function, installs middleware after the main transform middleware but + // before the built-in HTML middleware + return () => server.middlewares.use(function angularIndexMiddleware(req, res, next) { + if (req.url === '/' || req.url === `/index.html`) { + const rawHtml = outputFiles.get('/index.html')?.contents; + if (rawHtml) { + server + .transformIndexHtml(req.url, Buffer.from(rawHtml).toString('utf-8'), req.originalUrl) + .then((processedHtml) => { + res.setHeader('Content-Type', 'text/html'); + res.setHeader('Cache-Control', 'no-cache'); + if (serverOptions.headers) { + Object.entries(serverOptions.headers).forEach(([name, value]) => res.setHeader(name, value)); + } + res.end(processedHtml); + }) + .catch((error) => next(error)); + return; + } + } + next(); + }); + }, + }, + ], + optimizeDeps: { + // TODO: Consider enabling for known safe dependencies (@angular/* ?) + disabled: true, + }, + }; + if (serverOptions.ssl) { + if (serverOptions.sslCert && serverOptions.sslKey) { + // server configuration is defined above + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + configuration.server.https = { + cert: await (0, promises_1.readFile)(serverOptions.sslCert), + key: await (0, promises_1.readFile)(serverOptions.sslKey), + }; + } + else { + const { default: basicSslPlugin } = await Promise.resolve().then(() => __importStar(require('@vitejs/plugin-basic-ssl'))); + configuration.plugins ?? (configuration.plugins = []); + configuration.plugins.push(basicSslPlugin()); + } + } + return configuration; +} +exports.setupServer = setupServer; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vite-server.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/dev-server/vite-server.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 type { BuilderContext } from '@angular-devkit/architect';\nimport type { json } from '@angular-devkit/core';\nimport type { OutputFile } from 'esbuild';\nimport { lookup as lookupMimeType } from 'mrmime';\nimport assert from 'node:assert';\nimport { BinaryLike, createHash } from 'node:crypto';\nimport { readFile } from 'node:fs/promises';\nimport type { AddressInfo } from 'node:net';\nimport path from 'node:path';\nimport { InlineConfig, ViteDevServer, createServer, normalizePath } from 'vite';\nimport { buildEsbuildBrowser } from '../browser-esbuild';\nimport type { Schema as BrowserBuilderOptions } from '../browser-esbuild/schema';\nimport { loadProxyConfiguration } from './load-proxy-config';\nimport type { NormalizedDevServerOptions } from './options';\nimport type { DevServerBuilderOutput } from './webpack-server';\n\ninterface OutputFileRecord {\n  contents: Uint8Array;\n  size: number;\n  hash?: Buffer;\n  updated: boolean;\n}\n\nfunction hashContent(contents: BinaryLike): Buffer {\n  // TODO: Consider xxhash\n  return createHash('sha256').update(contents).digest();\n}\n\nexport async function* serveWithVite(\n  serverOptions: NormalizedDevServerOptions,\n  builderName: string,\n  context: BuilderContext,\n): AsyncIterableIterator<DevServerBuilderOutput> {\n  // Get the browser configuration from the target name.\n  const rawBrowserOptions = (await context.getTargetOptions(\n    serverOptions.browserTarget,\n  )) as json.JsonObject & BrowserBuilderOptions;\n\n  const browserOptions = (await context.validateOptions(\n    {\n      ...rawBrowserOptions,\n      watch: serverOptions.watch,\n      poll: serverOptions.poll,\n      verbose: serverOptions.verbose,\n    } as json.JsonObject & BrowserBuilderOptions,\n    builderName,\n  )) as json.JsonObject & BrowserBuilderOptions;\n\n  if (serverOptions.servePath === undefined && browserOptions.baseHref !== undefined) {\n    serverOptions.servePath = browserOptions.baseHref;\n  }\n\n  let server: ViteDevServer | undefined;\n  let listeningAddress: AddressInfo | undefined;\n  const generatedFiles = new Map<string, OutputFileRecord>();\n  const assetFiles = new Map<string, string>();\n  // TODO: Switch this to an architect schedule call when infrastructure settings are supported\n  for await (const result of buildEsbuildBrowser(browserOptions, context, { write: false })) {\n    assert(result.outputFiles, 'Builder did not provide result files.');\n\n    // Analyze result files for changes\n    analyzeResultFiles(result.outputFiles, generatedFiles);\n\n    assetFiles.clear();\n    if (result.assetFiles) {\n      for (const asset of result.assetFiles) {\n        assetFiles.set('/' + normalizePath(asset.destination), asset.source);\n      }\n    }\n\n    if (server) {\n      // Invalidate any updated files\n      for (const [file, record] of generatedFiles) {\n        if (record.updated) {\n          const updatedModules = server.moduleGraph.getModulesByFile(file);\n          updatedModules?.forEach((m) => server?.moduleGraph.invalidateModule(m));\n        }\n      }\n\n      // Send reload command to clients\n      if (serverOptions.liveReload) {\n        context.logger.info('Reloading client(s)...');\n\n        server.ws.send({\n          type: 'full-reload',\n          path: '*',\n        });\n      }\n    } else {\n      // Setup server and start listening\n      const serverConfiguration = await setupServer(serverOptions, generatedFiles, assetFiles);\n      server = await createServer(serverConfiguration);\n\n      await server.listen();\n      listeningAddress = server.httpServer?.address() as AddressInfo;\n\n      // log connection information\n      server.printUrls();\n    }\n\n    // TODO: adjust output typings to reflect both development servers\n    yield { success: true, port: listeningAddress?.port } as unknown as DevServerBuilderOutput;\n  }\n\n  if (server) {\n    let deferred: () => void;\n    context.addTeardown(async () => {\n      await server?.close();\n      deferred?.();\n    });\n    await new Promise<void>((resolve) => (deferred = resolve));\n  }\n}\n\nfunction analyzeResultFiles(\n  resultFiles: OutputFile[],\n  generatedFiles: Map<string, OutputFileRecord>,\n) {\n  const seen = new Set<string>(['/index.html']);\n  for (const file of resultFiles) {\n    const filePath = '/' + normalizePath(file.path);\n    seen.add(filePath);\n\n    // Skip analysis of sourcemaps\n    if (filePath.endsWith('.map')) {\n      generatedFiles.set(filePath, {\n        contents: file.contents,\n        size: file.contents.byteLength,\n        updated: false,\n      });\n\n      continue;\n    }\n\n    let fileHash: Buffer | undefined;\n    const existingRecord = generatedFiles.get(filePath);\n    if (existingRecord && existingRecord.size === file.contents.byteLength) {\n      // Only hash existing file when needed\n      if (existingRecord.hash === undefined) {\n        existingRecord.hash = hashContent(existingRecord.contents);\n      }\n\n      // Compare against latest result output\n      fileHash = hashContent(file.contents);\n      if (fileHash.equals(existingRecord.hash)) {\n        // Same file\n        existingRecord.updated = false;\n        continue;\n      }\n    }\n\n    generatedFiles.set(filePath, {\n      contents: file.contents,\n      size: file.contents.byteLength,\n      hash: fileHash,\n      updated: true,\n    });\n  }\n\n  // Clear stale output files\n  for (const file of generatedFiles.keys()) {\n    if (!seen.has(file)) {\n      generatedFiles.delete(file);\n    }\n  }\n}\n\nexport async function setupServer(\n  serverOptions: NormalizedDevServerOptions,\n  outputFiles: Map<string, OutputFileRecord>,\n  assets: Map<string, string>,\n): Promise<InlineConfig> {\n  const proxy = await loadProxyConfiguration(\n    serverOptions.workspaceRoot,\n    serverOptions.proxyConfig,\n  );\n\n  const configuration: InlineConfig = {\n    configFile: false,\n    envFile: false,\n    cacheDir: path.join(serverOptions.cacheOptions.path, 'vite'),\n    root: serverOptions.workspaceRoot,\n    publicDir: false,\n    esbuild: false,\n    mode: 'development',\n    appType: 'spa',\n    css: {\n      devSourcemap: true,\n    },\n    base: serverOptions.servePath,\n    server: {\n      port: serverOptions.port,\n      strictPort: true,\n      host: serverOptions.host,\n      open: serverOptions.open,\n      headers: serverOptions.headers,\n      proxy,\n      // Currently does not appear to be a way to disable file watching directly so ignore all files\n      watch: {\n        ignored: ['**/*'],\n      },\n    },\n    plugins: [\n      {\n        name: 'vite:angular-memory',\n        // Ensures plugin hooks run before built-in Vite hooks\n        enforce: 'pre',\n        async resolveId(source, importer) {\n          if (importer && source.startsWith('.')) {\n            // Remove query if present\n            const [importerFile] = importer.split('?', 1);\n\n            source = normalizePath(path.join(path.dirname(importerFile), source));\n          }\n\n          const [file] = source.split('?', 1);\n          if (outputFiles.has(file)) {\n            return source;\n          }\n        },\n        load(id) {\n          const [file] = id.split('?', 1);\n          const codeContents = outputFiles.get(file)?.contents;\n          if (codeContents === undefined) {\n            return;\n          }\n\n          const mapContents = outputFiles.get(file + '.map')?.contents;\n\n          return {\n            // Remove source map URL comments from the code if a sourcemap is present.\n            // Vite will inline and add an additional sourcemap URL for the sourcemap.\n            code: Buffer.from(codeContents).toString('utf-8'),\n            map: mapContents && Buffer.from(mapContents).toString('utf-8'),\n          };\n        },\n        configureServer(server) {\n          // Assets and resources get handled first\n          server.middlewares.use(function angularAssetsMiddleware(req, res, next) {\n            if (req.url === undefined || res.writableEnded) {\n              return;\n            }\n\n            // Parse the incoming request.\n            // The base of the URL is unused but required to parse the URL.\n            const parsedUrl = new URL(req.url, 'http://localhost');\n            let pathname = parsedUrl.pathname;\n            if (serverOptions.servePath && pathname.startsWith(serverOptions.servePath)) {\n              pathname = pathname.slice(serverOptions.servePath.length);\n              if (pathname[0] !== '/') {\n                pathname = '/' + pathname;\n              }\n            }\n            const extension = path.extname(pathname);\n\n            // Rewrite all build assets to a vite raw fs URL\n            const assetSourcePath = assets.get(pathname);\n            if (assetSourcePath !== undefined) {\n              req.url = `/@fs/${assetSourcePath}`;\n              next();\n\n              return;\n            }\n\n            // Resource files are handled directly.\n            // Global stylesheets (CSS files) are currently considered resources to workaround\n            // dev server sourcemap issues with stylesheets.\n            if (extension !== '.html') {\n              const outputFile = outputFiles.get(pathname);\n              if (outputFile) {\n                const mimeType = lookupMimeType(extension);\n                if (mimeType) {\n                  res.setHeader('Content-Type', mimeType);\n                }\n                res.setHeader('Cache-Control', 'no-cache');\n                if (serverOptions.headers) {\n                  Object.entries(serverOptions.headers).forEach(([name, value]) =>\n                    res.setHeader(name, value),\n                  );\n                }\n                res.end(outputFile.contents);\n\n                return;\n              }\n            }\n\n            next();\n          });\n\n          // Returning a function, installs middleware after the main transform middleware but\n          // before the built-in HTML middleware\n          return () =>\n            server.middlewares.use(function angularIndexMiddleware(req, res, next) {\n              if (req.url === '/' || req.url === `/index.html`) {\n                const rawHtml = outputFiles.get('/index.html')?.contents;\n                if (rawHtml) {\n                  server\n                    .transformIndexHtml(\n                      req.url,\n                      Buffer.from(rawHtml).toString('utf-8'),\n                      req.originalUrl,\n                    )\n                    .then((processedHtml) => {\n                      res.setHeader('Content-Type', 'text/html');\n                      res.setHeader('Cache-Control', 'no-cache');\n                      if (serverOptions.headers) {\n                        Object.entries(serverOptions.headers).forEach(([name, value]) =>\n                          res.setHeader(name, value),\n                        );\n                      }\n                      res.end(processedHtml);\n                    })\n                    .catch((error) => next(error));\n\n                  return;\n                }\n              }\n\n              next();\n            });\n        },\n      },\n    ],\n    optimizeDeps: {\n      // TODO: Consider enabling for known safe dependencies (@angular/* ?)\n      disabled: true,\n    },\n  };\n\n  if (serverOptions.ssl) {\n    if (serverOptions.sslCert && serverOptions.sslKey) {\n      // server configuration is defined above\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      configuration.server!.https = {\n        cert: await readFile(serverOptions.sslCert),\n        key: await readFile(serverOptions.sslKey),\n      };\n    } else {\n      const { default: basicSslPlugin } = await import('@vitejs/plugin-basic-ssl');\n      configuration.plugins ??= [];\n      configuration.plugins.push(basicSslPlugin());\n    }\n  }\n\n  return configuration;\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/dev-server/webpack-server.d.ts b/artifacts/build-angular/src/builders/dev-server/webpack-server.d.ts new file mode 100644 index 00000000..9bd81ad9 --- /dev/null +++ b/artifacts/build-angular/src/builders/dev-server/webpack-server.d.ts @@ -0,0 +1,35 @@ +/** + * @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 { DevServerBuildOutput, WebpackLoggingCallback } from '@angular-devkit/build-webpack'; +import { Observable } from 'rxjs'; +import webpack from 'webpack'; +import { ExecutionTransformer } from '../../transforms'; +import { IndexHtmlTransform } from '../../utils/index-file/index-html-generator'; +import { BuildEventStats } from '../../webpack/utils/stats'; +import { NormalizedDevServerOptions } from './options'; +/** + * @experimental Direct usage of this type is considered experimental. + */ +export type DevServerBuilderOutput = DevServerBuildOutput & { + baseUrl: string; + stats: BuildEventStats; +}; +/** + * Reusable implementation of the Angular Webpack development server builder. + * @param options Dev Server options. + * @param builderName The name of the builder used to build the application. + * @param context The build context. + * @param transforms A map of transforms that can be used to hook into some logic (such as + * transforming webpack configuration before passing it to webpack). + */ +export declare function serveWebpackBrowser(options: NormalizedDevServerOptions, builderName: string, context: BuilderContext, transforms?: { + webpackConfiguration?: ExecutionTransformer; + logging?: WebpackLoggingCallback; + indexHtml?: IndexHtmlTransform; +}): Observable; diff --git a/artifacts/build-angular/src/builders/dev-server/webpack-server.js b/artifacts/build-angular/src/builders/dev-server/webpack-server.js new file mode 100644 index 00000000..f5e58eec --- /dev/null +++ b/artifacts/build-angular/src/builders/dev-server/webpack-server.js @@ -0,0 +1,287 @@ +"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.serveWebpackBrowser = void 0; +const build_webpack_1 = require("@angular-devkit/build-webpack"); +const core_1 = require("@angular-devkit/core"); +const path = __importStar(require("path")); +const rxjs_1 = require("rxjs"); +const url = __importStar(require("url")); +const utils_1 = require("../../utils"); +const color_1 = require("../../utils/color"); +const i18n_options_1 = require("../../utils/i18n-options"); +const load_translations_1 = require("../../utils/load-translations"); +const package_chunk_sort_1 = require("../../utils/package-chunk-sort"); +const version_1 = require("../../utils/version"); +const webpack_browser_config_1 = require("../../utils/webpack-browser-config"); +const webpack_diagnostics_1 = require("../../utils/webpack-diagnostics"); +const configs_1 = require("../../webpack/configs"); +const index_html_webpack_plugin_1 = require("../../webpack/plugins/index-html-webpack-plugin"); +const service_worker_plugin_1 = require("../../webpack/plugins/service-worker-plugin"); +const stats_1 = require("../../webpack/utils/stats"); +const schema_1 = require("../browser/schema"); +/** + * Reusable implementation of the Angular Webpack development server builder. + * @param options Dev Server options. + * @param builderName The name of the builder used to build the application. + * @param context The build context. + * @param transforms A map of transforms that can be used to hook into some logic (such as + * transforming webpack configuration before passing it to webpack). + */ +// eslint-disable-next-line max-lines-per-function +function serveWebpackBrowser(options, builderName, context, transforms = {}) { + // Check Angular version. + const { logger, workspaceRoot } = context; + (0, version_1.assertCompatibleAngularVersion)(workspaceRoot); + async function setup() { + if (options.hmr) { + logger.warn(core_1.tags.stripIndents `NOTICE: Hot Module Replacement (HMR) is enabled for the dev server. + See https://webpack.js.org/guides/hot-module-replacement for information on working with HMR for Webpack.`); + } + // Get the browser configuration from the target name. + const rawBrowserOptions = (await context.getTargetOptions(options.browserTarget)); + if (rawBrowserOptions.outputHashing && rawBrowserOptions.outputHashing !== schema_1.OutputHashing.None) { + // Disable output hashing for dev build as this can cause memory leaks + // See: https://github.com/webpack/webpack-dev-server/issues/377#issuecomment-241258405 + rawBrowserOptions.outputHashing = schema_1.OutputHashing.None; + logger.warn(`Warning: 'outputHashing' option is disabled when using the dev-server.`); + } + const browserOptions = (await context.validateOptions({ + ...rawBrowserOptions, + watch: options.watch, + verbose: options.verbose, + // In dev server we should not have budgets because of extra libs such as socks-js + budgets: undefined, + }, builderName)); + const { styles, scripts } = (0, utils_1.normalizeOptimization)(browserOptions.optimization); + if (scripts || styles.minify) { + 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! + **************************************************************************************** + `); + } + const { config, i18n } = await (0, webpack_browser_config_1.generateI18nBrowserWebpackConfigFromContext)(browserOptions, context, (wco) => [(0, configs_1.getDevServerConfig)(wco), (0, configs_1.getCommonConfig)(wco), (0, configs_1.getStylesConfig)(wco)], options); + if (!config.devServer) { + throw new Error('Webpack Dev Server configuration was not set.'); + } + let locale; + if (i18n.shouldInline) { + // Dev-server only supports one locale + locale = [...i18n.inlineLocales][0]; + } + else if (i18n.hasDefinedSourceLocale) { + // use source locale if not localizing + locale = i18n.sourceLocale; + } + let webpackConfig = config; + // If a locale is defined, setup localization + if (locale) { + if (i18n.inlineLocales.size > 1) { + throw new Error('The development server only supports localizing a single locale per build.'); + } + await setupLocalize(locale, i18n, browserOptions, webpackConfig, options.cacheOptions, context); + } + if (transforms.webpackConfiguration) { + webpackConfig = await transforms.webpackConfiguration(webpackConfig); + } + webpackConfig.plugins ?? (webpackConfig.plugins = []); + if (browserOptions.index) { + const { scripts = [], styles = [], baseHref } = browserOptions; + const entrypoints = (0, package_chunk_sort_1.generateEntryPoints)({ + scripts, + styles, + // The below is needed as otherwise HMR for CSS will break. + // styles.js and runtime.js needs to be loaded as a non-module scripts as otherwise `document.currentScript` will be null. + // https://github.com/webpack-contrib/mini-css-extract-plugin/blob/90445dd1d81da0c10b9b0e8a17b417d0651816b8/src/hmr/hotModuleReplacement.js#L39 + isHMREnabled: !!webpackConfig.devServer?.hot, + }); + webpackConfig.plugins.push(new index_html_webpack_plugin_1.IndexHtmlWebpackPlugin({ + indexPath: path.resolve(workspaceRoot, (0, webpack_browser_config_1.getIndexInputFile)(browserOptions.index)), + outputPath: (0, webpack_browser_config_1.getIndexOutputFile)(browserOptions.index), + baseHref, + entrypoints, + deployUrl: browserOptions.deployUrl, + sri: browserOptions.subresourceIntegrity, + cache: options.cacheOptions, + postTransform: transforms.indexHtml, + optimization: (0, utils_1.normalizeOptimization)(browserOptions.optimization), + crossOrigin: browserOptions.crossOrigin, + lang: locale, + })); + } + if (browserOptions.serviceWorker) { + webpackConfig.plugins.push(new service_worker_plugin_1.ServiceWorkerPlugin({ + baseHref: browserOptions.baseHref, + root: context.workspaceRoot, + projectRoot: options.projectRoot, + ngswConfigPath: browserOptions.ngswConfigPath, + })); + } + return { + browserOptions, + webpackConfig, + }; + } + return (0, rxjs_1.from)(setup()).pipe((0, rxjs_1.switchMap)(({ browserOptions, webpackConfig }) => { + return (0, build_webpack_1.runWebpackDevServer)(webpackConfig, context, { + logging: transforms.logging || (0, stats_1.createWebpackLoggingCallback)(browserOptions, logger), + webpackFactory: require('webpack'), + webpackDevServerFactory: require('webpack-dev-server'), + }).pipe((0, rxjs_1.concatMap)(async (buildEvent, index) => { + const webpackRawStats = buildEvent.webpackStats; + if (!webpackRawStats) { + throw new Error('Webpack stats build result is required.'); + } + // Resolve serve address. + const publicPath = webpackConfig.devServer?.devMiddleware?.publicPath; + const serverAddress = url.format({ + protocol: options.ssl ? 'https' : 'http', + hostname: options.host === '0.0.0.0' ? 'localhost' : options.host, + port: buildEvent.port, + pathname: typeof publicPath === 'string' ? publicPath : undefined, + }); + if (index === 0) { + logger.info('\n' + + core_1.tags.oneLine ` + ** + Angular Live Development Server is listening on ${options.host}:${buildEvent.port}, + open your browser on ${serverAddress} + ** + ` + + '\n'); + if (options.open) { + const open = (await Promise.resolve().then(() => __importStar(require('open')))).default; + await open(serverAddress); + } + } + if (buildEvent.success) { + logger.info(`\n${color_1.colors.greenBright(color_1.colors.symbols.check)} Compiled successfully.`); + } + else { + logger.info(`\n${color_1.colors.redBright(color_1.colors.symbols.cross)} Failed to compile.`); + } + return { + ...buildEvent, + baseUrl: serverAddress, + stats: (0, stats_1.generateBuildEventStats)(webpackRawStats, browserOptions), + }; + })); + })); +} +exports.serveWebpackBrowser = serveWebpackBrowser; +async function setupLocalize(locale, i18n, browserOptions, webpackConfig, cacheOptions, context) { + const localeDescription = i18n.locales[locale]; + // Modify main entrypoint to include locale data + if (localeDescription?.dataPath && + typeof webpackConfig.entry === 'object' && + !Array.isArray(webpackConfig.entry) && + webpackConfig.entry['main']) { + if (Array.isArray(webpackConfig.entry['main'])) { + webpackConfig.entry['main'].unshift(localeDescription.dataPath); + } + else { + webpackConfig.entry['main'] = [ + localeDescription.dataPath, + webpackConfig.entry['main'], + ]; + } + } + let missingTranslationBehavior = browserOptions.i18nMissingTranslation || 'ignore'; + let translation = localeDescription?.translation || {}; + if (locale === i18n.sourceLocale) { + missingTranslationBehavior = 'ignore'; + translation = {}; + } + const i18nLoaderOptions = { + locale, + missingTranslationBehavior, + translation: i18n.shouldInline ? translation : undefined, + translationFiles: localeDescription?.files.map((file) => path.resolve(context.workspaceRoot, file.path)), + }; + const i18nRule = { + test: /\.[cm]?[tj]sx?$/, + enforce: 'post', + use: [ + { + loader: require.resolve('../../babel/webpack-loader'), + options: { + cacheDirectory: (cacheOptions.enabled && path.join(cacheOptions.path, 'babel-dev-server-i18n')) || + false, + cacheIdentifier: JSON.stringify({ + locale, + translationIntegrity: localeDescription?.files.map((file) => file.integrity), + }), + i18n: i18nLoaderOptions, + }, + }, + ], + }; + // Get the rules and ensure the Webpack configuration is setup properly + const rules = webpackConfig.module?.rules || []; + if (!webpackConfig.module) { + webpackConfig.module = { rules }; + } + else if (!webpackConfig.module.rules) { + webpackConfig.module.rules = rules; + } + rules.push(i18nRule); + // Add a plugin to reload translation files on rebuilds + const loader = await (0, load_translations_1.createTranslationLoader)(); + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + webpackConfig.plugins.push({ + apply: (compiler) => { + compiler.hooks.thisCompilation.tap('build-angular', (compilation) => { + if (i18n.shouldInline && i18nLoaderOptions.translation === undefined) { + // Reload translations + (0, i18n_options_1.loadTranslations)(locale, localeDescription, context.workspaceRoot, loader, { + warn(message) { + (0, webpack_diagnostics_1.addWarning)(compilation, message); + }, + error(message) { + (0, webpack_diagnostics_1.addError)(compilation, message); + }, + }, undefined, browserOptions.i18nDuplicateTranslation); + i18nLoaderOptions.translation = localeDescription.translation ?? {}; + } + compilation.hooks.finishModules.tap('build-angular', () => { + // After loaders are finished, clear out the now unneeded translations + i18nLoaderOptions.translation = undefined; + }); + }); + }, + }); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"webpack-server.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/dev-server/webpack-server.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,iEAIuC;AACvC,+CAAkD;AAClD,2CAA6B;AAC7B,+BAA8D;AAC9D,yCAA2B;AAI3B,uCAAoD;AACpD,6CAA2C;AAC3C,2DAAyE;AAEzE,qEAAwE;AAExE,uEAAqE;AACrE,iDAAqE;AACrE,+EAI4C;AAC5C,yEAAuE;AACvE,mDAA6F;AAC7F,+FAAyF;AACzF,uFAAkF;AAClF,qDAImC;AACnC,8CAAkF;AAWlF;;;;;;;GAOG;AACH,kDAAkD;AAClD,SAAgB,mBAAmB,CACjC,OAAmC,EACnC,WAAmB,EACnB,OAAuB,EACvB,aAII,EAAE;IAEN,yBAAyB;IACzB,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,GAAG,OAAO,CAAC;IAC1C,IAAA,wCAA8B,EAAC,aAAa,CAAC,CAAC;IAE9C,KAAK,UAAU,KAAK;QAIlB,IAAI,OAAO,CAAC,GAAG,EAAE;YACf,MAAM,CAAC,IAAI,CAAC,WAAI,CAAC,YAAY,CAAA;gHAC6E,CAAC,CAAC;SAC7G;QAED,sDAAsD;QACtD,MAAM,iBAAiB,GAAG,CAAC,MAAM,OAAO,CAAC,gBAAgB,CACvD,OAAO,CAAC,aAAa,CACtB,CAA2C,CAAC;QAE7C,IAAI,iBAAiB,CAAC,aAAa,IAAI,iBAAiB,CAAC,aAAa,KAAK,sBAAa,CAAC,IAAI,EAAE;YAC7F,sEAAsE;YACtE,uFAAuF;YACvF,iBAAiB,CAAC,aAAa,GAAG,sBAAa,CAAC,IAAI,CAAC;YACrD,MAAM,CAAC,IAAI,CAAC,wEAAwE,CAAC,CAAC;SACvF;QAED,MAAM,cAAc,GAAG,CAAC,MAAM,OAAO,CAAC,eAAe,CACnD;YACE,GAAG,iBAAiB;YACpB,KAAK,EAAE,OAAO,CAAC,KAAK;YACpB,OAAO,EAAE,OAAO,CAAC,OAAO;YACxB,kFAAkF;YAClF,OAAO,EAAE,SAAS;SACuB,EAC3C,WAAW,CACZ,CAA2C,CAAC;QAE7C,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,IAAA,6BAAqB,EAAC,cAAc,CAAC,YAAY,CAAC,CAAC;QAC/E,IAAI,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE;YAC5B,MAAM,CAAC,KAAK,CAAC,WAAI,CAAC,YAAY,CAAA;;;;;;;OAO7B,CAAC,CAAC;SACJ;QAED,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,IAAA,oEAA2C,EACxE,cAAc,EACd,OAAO,EACP,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,IAAA,4BAAkB,EAAC,GAAG,CAAC,EAAE,IAAA,yBAAe,EAAC,GAAG,CAAC,EAAE,IAAA,yBAAe,EAAC,GAAG,CAAC,CAAC,EAC9E,OAAO,CACR,CAAC;QAEF,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE;YACrB,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;SAClE;QAED,IAAI,MAA0B,CAAC;QAC/B,IAAI,IAAI,CAAC,YAAY,EAAE;YACrB,sCAAsC;YACtC,MAAM,GAAG,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;SACrC;aAAM,IAAI,IAAI,CAAC,sBAAsB,EAAE;YACtC,sCAAsC;YACtC,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC;SAC5B;QAED,IAAI,aAAa,GAAG,MAAM,CAAC;QAE3B,6CAA6C;QAC7C,IAAI,MAAM,EAAE;YACV,IAAI,IAAI,CAAC,aAAa,CAAC,IAAI,GAAG,CAAC,EAAE;gBAC/B,MAAM,IAAI,KAAK,CACb,4EAA4E,CAC7E,CAAC;aACH;YAED,MAAM,aAAa,CACjB,MAAM,EACN,IAAI,EACJ,cAAc,EACd,aAAa,EACb,OAAO,CAAC,YAAY,EACpB,OAAO,CACR,CAAC;SACH;QAED,IAAI,UAAU,CAAC,oBAAoB,EAAE;YACnC,aAAa,GAAG,MAAM,UAAU,CAAC,oBAAoB,CAAC,aAAa,CAAC,CAAC;SACtE;QAED,aAAa,CAAC,OAAO,KAArB,aAAa,CAAC,OAAO,GAAK,EAAE,EAAC;QAE7B,IAAI,cAAc,CAAC,KAAK,EAAE;YACxB,MAAM,EAAE,OAAO,GAAG,EAAE,EAAE,MAAM,GAAG,EAAE,EAAE,QAAQ,EAAE,GAAG,cAAc,CAAC;YAC/D,MAAM,WAAW,GAAG,IAAA,wCAAmB,EAAC;gBACtC,OAAO;gBACP,MAAM;gBACN,2DAA2D;gBAC3D,0HAA0H;gBAC1H,+IAA+I;gBAC/I,YAAY,EAAE,CAAC,CAAC,aAAa,CAAC,SAAS,EAAE,GAAG;aAC7C,CAAC,CAAC;YAEH,aAAa,CAAC,OAAO,CAAC,IAAI,CACxB,IAAI,kDAAsB,CAAC;gBACzB,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,IAAA,0CAAiB,EAAC,cAAc,CAAC,KAAK,CAAC,CAAC;gBAC/E,UAAU,EAAE,IAAA,2CAAkB,EAAC,cAAc,CAAC,KAAK,CAAC;gBACpD,QAAQ;gBACR,WAAW;gBACX,SAAS,EAAE,cAAc,CAAC,SAAS;gBACnC,GAAG,EAAE,cAAc,CAAC,oBAAoB;gBACxC,KAAK,EAAE,OAAO,CAAC,YAAY;gBAC3B,aAAa,EAAE,UAAU,CAAC,SAAS;gBACnC,YAAY,EAAE,IAAA,6BAAqB,EAAC,cAAc,CAAC,YAAY,CAAC;gBAChE,WAAW,EAAE,cAAc,CAAC,WAAW;gBACvC,IAAI,EAAE,MAAM;aACb,CAAC,CACH,CAAC;SACH;QAED,IAAI,cAAc,CAAC,aAAa,EAAE;YAChC,aAAa,CAAC,OAAO,CAAC,IAAI,CACxB,IAAI,2CAAmB,CAAC;gBACtB,QAAQ,EAAE,cAAc,CAAC,QAAQ;gBACjC,IAAI,EAAE,OAAO,CAAC,aAAa;gBAC3B,WAAW,EAAE,OAAO,CAAC,WAAW;gBAChC,cAAc,EAAE,cAAc,CAAC,cAAc;aAC9C,CAAC,CACH,CAAC;SACH;QAED,OAAO;YACL,cAAc;YACd,aAAa;SACd,CAAC;IACJ,CAAC;IAED,OAAO,IAAA,WAAI,EAAC,KAAK,EAAE,CAAC,CAAC,IAAI,CACvB,IAAA,gBAAS,EAAC,CAAC,EAAE,cAAc,EAAE,aAAa,EAAE,EAAE,EAAE;QAC9C,OAAO,IAAA,mCAAmB,EAAC,aAAa,EAAE,OAAO,EAAE;YACjD,OAAO,EAAE,UAAU,CAAC,OAAO,IAAI,IAAA,oCAA4B,EAAC,cAAc,EAAE,MAAM,CAAC;YACnF,cAAc,EAAE,OAAO,CAAC,SAAS,CAAmB;YACpD,uBAAuB,EAAE,OAAO,CAAC,oBAAoB,CAA4B;SAClF,CAAC,CAAC,IAAI,CACL,IAAA,gBAAS,EAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,EAAE;YACpC,MAAM,eAAe,GAAG,UAAU,CAAC,YAAY,CAAC;YAChD,IAAI,CAAC,eAAe,EAAE;gBACpB,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;aAC5D;YAED,yBAAyB;YACzB,MAAM,UAAU,GAAG,aAAa,CAAC,SAAS,EAAE,aAAa,EAAE,UAAU,CAAC;YAEtE,MAAM,aAAa,GAAG,GAAG,CAAC,MAAM,CAAC;gBAC/B,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM;gBACxC,QAAQ,EAAE,OAAO,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI;gBACjE,IAAI,EAAE,UAAU,CAAC,IAAI;gBACrB,QAAQ,EAAE,OAAO,UAAU,KAAK,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS;aAClE,CAAC,CAAC;YAEH,IAAI,KAAK,KAAK,CAAC,EAAE;gBACf,MAAM,CAAC,IAAI,CACT,IAAI;oBACF,WAAI,CAAC,OAAO,CAAA;;gEAEoC,OAAO,CAAC,IAAI,IAAI,UAAU,CAAC,IAAI;qCAC1D,aAAa;;aAErC;oBACG,IAAI,CACP,CAAC;gBAEF,IAAI,OAAO,CAAC,IAAI,EAAE;oBAChB,MAAM,IAAI,GAAG,CAAC,wDAAa,MAAM,GAAC,CAAC,CAAC,OAAO,CAAC;oBAC5C,MAAM,IAAI,CAAC,aAAa,CAAC,CAAC;iBAC3B;aACF;YAED,IAAI,UAAU,CAAC,OAAO,EAAE;gBACtB,MAAM,CAAC,IAAI,CAAC,KAAK,cAAM,CAAC,WAAW,CAAC,cAAM,CAAC,OAAO,CAAC,KAAK,CAAC,yBAAyB,CAAC,CAAC;aACrF;iBAAM;gBACL,MAAM,CAAC,IAAI,CAAC,KAAK,cAAM,CAAC,SAAS,CAAC,cAAM,CAAC,OAAO,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC;aAC/E;YAED,OAAO;gBACL,GAAG,UAAU;gBACb,OAAO,EAAE,aAAa;gBACtB,KAAK,EAAE,IAAA,+BAAuB,EAAC,eAAe,EAAE,cAAc,CAAC;aACtC,CAAC;QAC9B,CAAC,CAAC,CACH,CAAC;IACJ,CAAC,CAAC,CACH,CAAC;AACJ,CAAC;AA7MD,kDA6MC;AAED,KAAK,UAAU,aAAa,CAC1B,MAAc,EACd,IAAiB,EACjB,cAAoC,EACpC,aAAoC,EACpC,YAAqC,EACrC,OAAuB;IAEvB,MAAM,iBAAiB,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAE/C,gDAAgD;IAChD,IACE,iBAAiB,EAAE,QAAQ;QAC3B,OAAO,aAAa,CAAC,KAAK,KAAK,QAAQ;QACvC,CAAC,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC;QACnC,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC,EAC3B;QACA,IAAI,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,EAAE;YAC9C,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC;SACjE;aAAM;YACL,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG;gBAC5B,iBAAiB,CAAC,QAAQ;gBAC1B,aAAa,CAAC,KAAK,CAAC,MAAM,CAAW;aACtC,CAAC;SACH;KACF;IAED,IAAI,0BAA0B,GAAG,cAAc,CAAC,sBAAsB,IAAI,QAAQ,CAAC;IACnF,IAAI,WAAW,GAAG,iBAAiB,EAAE,WAAW,IAAI,EAAE,CAAC;IAEvD,IAAI,MAAM,KAAK,IAAI,CAAC,YAAY,EAAE;QAChC,0BAA0B,GAAG,QAAQ,CAAC;QACtC,WAAW,GAAG,EAAE,CAAC;KAClB;IAED,MAAM,iBAAiB,GAAG;QACxB,MAAM;QACN,0BAA0B;QAC1B,WAAW,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS;QACxD,gBAAgB,EAAE,iBAAiB,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CACtD,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,aAAa,EAAE,IAAI,CAAC,IAAI,CAAC,CAC/C;KACF,CAAC;IAEF,MAAM,QAAQ,GAAwB;QACpC,IAAI,EAAE,iBAAiB;QACvB,OAAO,EAAE,MAAM;QACf,GAAG,EAAE;YACH;gBACE,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,4BAA4B,CAAC;gBACrD,OAAO,EAAE;oBACP,cAAc,EACZ,CAAC,YAAY,CAAC,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,uBAAuB,CAAC,CAAC;wBAC/E,KAAK;oBACP,eAAe,EAAE,IAAI,CAAC,SAAS,CAAC;wBAC9B,MAAM;wBACN,oBAAoB,EAAE,iBAAiB,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC;qBAC7E,CAAC;oBACF,IAAI,EAAE,iBAAiB;iBACxB;aACF;SACF;KACF,CAAC;IAEF,uEAAuE;IACvE,MAAM,KAAK,GAAG,aAAa,CAAC,MAAM,EAAE,KAAK,IAAI,EAAE,CAAC;IAChD,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE;QACzB,aAAa,CAAC,MAAM,GAAG,EAAE,KAAK,EAAE,CAAC;KAClC;SAAM,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,EAAE;QACtC,aAAa,CAAC,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC;KACpC;IAED,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAErB,uDAAuD;IACvD,MAAM,MAAM,GAAG,MAAM,IAAA,2CAAuB,GAAE,CAAC;IAC/C,oEAAoE;IACpE,aAAa,CAAC,OAAQ,CAAC,IAAI,CAAC;QAC1B,KAAK,EAAE,CAAC,QAA0B,EAAE,EAAE;YACpC,QAAQ,CAAC,KAAK,CAAC,eAAe,CAAC,GAAG,CAAC,eAAe,EAAE,CAAC,WAAW,EAAE,EAAE;gBAClE,IAAI,IAAI,CAAC,YAAY,IAAI,iBAAiB,CAAC,WAAW,KAAK,SAAS,EAAE;oBACpE,sBAAsB;oBACtB,IAAA,+BAAgB,EACd,MAAM,EACN,iBAAiB,EACjB,OAAO,CAAC,aAAa,EACrB,MAAM,EACN;wBACE,IAAI,CAAC,OAAO;4BACV,IAAA,gCAAU,EAAC,WAAW,EAAE,OAAO,CAAC,CAAC;wBACnC,CAAC;wBACD,KAAK,CAAC,OAAO;4BACX,IAAA,8BAAQ,EAAC,WAAW,EAAE,OAAO,CAAC,CAAC;wBACjC,CAAC;qBACF,EACD,SAAS,EACT,cAAc,CAAC,wBAAwB,CACxC,CAAC;oBAEF,iBAAiB,CAAC,WAAW,GAAG,iBAAiB,CAAC,WAAW,IAAI,EAAE,CAAC;iBACrE;gBAED,WAAW,CAAC,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,eAAe,EAAE,GAAG,EAAE;oBACxD,sEAAsE;oBACtE,iBAAiB,CAAC,WAAW,GAAG,SAAS,CAAC;gBAC5C,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;QACL,CAAC;KACF,CAAC,CAAC;AACL,CAAC","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 { BuilderContext } from '@angular-devkit/architect';\nimport {\n  DevServerBuildOutput,\n  WebpackLoggingCallback,\n  runWebpackDevServer,\n} from '@angular-devkit/build-webpack';\nimport { json, tags } from '@angular-devkit/core';\nimport * as path from 'path';\nimport { Observable, concatMap, from, switchMap } from 'rxjs';\nimport * as url from 'url';\nimport webpack from 'webpack';\nimport webpackDevServer from 'webpack-dev-server';\nimport { ExecutionTransformer } from '../../transforms';\nimport { normalizeOptimization } from '../../utils';\nimport { colors } from '../../utils/color';\nimport { I18nOptions, loadTranslations } from '../../utils/i18n-options';\nimport { IndexHtmlTransform } from '../../utils/index-file/index-html-generator';\nimport { createTranslationLoader } from '../../utils/load-translations';\nimport { NormalizedCachedOptions } from '../../utils/normalize-cache';\nimport { generateEntryPoints } from '../../utils/package-chunk-sort';\nimport { assertCompatibleAngularVersion } from '../../utils/version';\nimport {\n  generateI18nBrowserWebpackConfigFromContext,\n  getIndexInputFile,\n  getIndexOutputFile,\n} from '../../utils/webpack-browser-config';\nimport { addError, addWarning } from '../../utils/webpack-diagnostics';\nimport { getCommonConfig, getDevServerConfig, getStylesConfig } from '../../webpack/configs';\nimport { IndexHtmlWebpackPlugin } from '../../webpack/plugins/index-html-webpack-plugin';\nimport { ServiceWorkerPlugin } from '../../webpack/plugins/service-worker-plugin';\nimport {\n  BuildEventStats,\n  createWebpackLoggingCallback,\n  generateBuildEventStats,\n} from '../../webpack/utils/stats';\nimport { Schema as BrowserBuilderSchema, OutputHashing } from '../browser/schema';\nimport { NormalizedDevServerOptions } from './options';\n\n/**\n * @experimental Direct usage of this type is considered experimental.\n */\nexport type DevServerBuilderOutput = DevServerBuildOutput & {\n  baseUrl: string;\n  stats: BuildEventStats;\n};\n\n/**\n * Reusable implementation of the Angular Webpack development server builder.\n * @param options Dev Server options.\n * @param builderName The name of the builder used to build the application.\n * @param context The build context.\n * @param transforms A map of transforms that can be used to hook into some logic (such as\n *     transforming webpack configuration before passing it to webpack).\n */\n// eslint-disable-next-line max-lines-per-function\nexport function serveWebpackBrowser(\n  options: NormalizedDevServerOptions,\n  builderName: string,\n  context: BuilderContext,\n  transforms: {\n    webpackConfiguration?: ExecutionTransformer<webpack.Configuration>;\n    logging?: WebpackLoggingCallback;\n    indexHtml?: IndexHtmlTransform;\n  } = {},\n): Observable<DevServerBuilderOutput> {\n  // Check Angular version.\n  const { logger, workspaceRoot } = context;\n  assertCompatibleAngularVersion(workspaceRoot);\n\n  async function setup(): Promise<{\n    browserOptions: BrowserBuilderSchema;\n    webpackConfig: webpack.Configuration;\n  }> {\n    if (options.hmr) {\n      logger.warn(tags.stripIndents`NOTICE: Hot Module Replacement (HMR) is enabled for the dev server.\n      See https://webpack.js.org/guides/hot-module-replacement for information on working with HMR for Webpack.`);\n    }\n\n    // Get the browser configuration from the target name.\n    const rawBrowserOptions = (await context.getTargetOptions(\n      options.browserTarget,\n    )) as json.JsonObject & BrowserBuilderSchema;\n\n    if (rawBrowserOptions.outputHashing && rawBrowserOptions.outputHashing !== OutputHashing.None) {\n      // Disable output hashing for dev build as this can cause memory leaks\n      // See: https://github.com/webpack/webpack-dev-server/issues/377#issuecomment-241258405\n      rawBrowserOptions.outputHashing = OutputHashing.None;\n      logger.warn(`Warning: 'outputHashing' option is disabled when using the dev-server.`);\n    }\n\n    const browserOptions = (await context.validateOptions(\n      {\n        ...rawBrowserOptions,\n        watch: options.watch,\n        verbose: options.verbose,\n        // In dev server we should not have budgets because of extra libs such as socks-js\n        budgets: undefined,\n      } as json.JsonObject & BrowserBuilderSchema,\n      builderName,\n    )) as json.JsonObject & BrowserBuilderSchema;\n\n    const { styles, scripts } = normalizeOptimization(browserOptions.optimization);\n    if (scripts || styles.minify) {\n      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\n    const { config, i18n } = await generateI18nBrowserWebpackConfigFromContext(\n      browserOptions,\n      context,\n      (wco) => [getDevServerConfig(wco), getCommonConfig(wco), getStylesConfig(wco)],\n      options,\n    );\n\n    if (!config.devServer) {\n      throw new Error('Webpack Dev Server configuration was not set.');\n    }\n\n    let locale: string | undefined;\n    if (i18n.shouldInline) {\n      // Dev-server only supports one locale\n      locale = [...i18n.inlineLocales][0];\n    } else if (i18n.hasDefinedSourceLocale) {\n      // use source locale if not localizing\n      locale = i18n.sourceLocale;\n    }\n\n    let webpackConfig = config;\n\n    // If a locale is defined, setup localization\n    if (locale) {\n      if (i18n.inlineLocales.size > 1) {\n        throw new Error(\n          'The development server only supports localizing a single locale per build.',\n        );\n      }\n\n      await setupLocalize(\n        locale,\n        i18n,\n        browserOptions,\n        webpackConfig,\n        options.cacheOptions,\n        context,\n      );\n    }\n\n    if (transforms.webpackConfiguration) {\n      webpackConfig = await transforms.webpackConfiguration(webpackConfig);\n    }\n\n    webpackConfig.plugins ??= [];\n\n    if (browserOptions.index) {\n      const { scripts = [], styles = [], baseHref } = browserOptions;\n      const entrypoints = generateEntryPoints({\n        scripts,\n        styles,\n        // The below is needed as otherwise HMR for CSS will break.\n        // styles.js and runtime.js needs to be loaded as a non-module scripts as otherwise `document.currentScript` will be null.\n        // https://github.com/webpack-contrib/mini-css-extract-plugin/blob/90445dd1d81da0c10b9b0e8a17b417d0651816b8/src/hmr/hotModuleReplacement.js#L39\n        isHMREnabled: !!webpackConfig.devServer?.hot,\n      });\n\n      webpackConfig.plugins.push(\n        new IndexHtmlWebpackPlugin({\n          indexPath: path.resolve(workspaceRoot, getIndexInputFile(browserOptions.index)),\n          outputPath: getIndexOutputFile(browserOptions.index),\n          baseHref,\n          entrypoints,\n          deployUrl: browserOptions.deployUrl,\n          sri: browserOptions.subresourceIntegrity,\n          cache: options.cacheOptions,\n          postTransform: transforms.indexHtml,\n          optimization: normalizeOptimization(browserOptions.optimization),\n          crossOrigin: browserOptions.crossOrigin,\n          lang: locale,\n        }),\n      );\n    }\n\n    if (browserOptions.serviceWorker) {\n      webpackConfig.plugins.push(\n        new ServiceWorkerPlugin({\n          baseHref: browserOptions.baseHref,\n          root: context.workspaceRoot,\n          projectRoot: options.projectRoot,\n          ngswConfigPath: browserOptions.ngswConfigPath,\n        }),\n      );\n    }\n\n    return {\n      browserOptions,\n      webpackConfig,\n    };\n  }\n\n  return from(setup()).pipe(\n    switchMap(({ browserOptions, webpackConfig }) => {\n      return runWebpackDevServer(webpackConfig, context, {\n        logging: transforms.logging || createWebpackLoggingCallback(browserOptions, logger),\n        webpackFactory: require('webpack') as typeof webpack,\n        webpackDevServerFactory: require('webpack-dev-server') as typeof webpackDevServer,\n      }).pipe(\n        concatMap(async (buildEvent, index) => {\n          const webpackRawStats = buildEvent.webpackStats;\n          if (!webpackRawStats) {\n            throw new Error('Webpack stats build result is required.');\n          }\n\n          // Resolve serve address.\n          const publicPath = webpackConfig.devServer?.devMiddleware?.publicPath;\n\n          const serverAddress = url.format({\n            protocol: options.ssl ? 'https' : 'http',\n            hostname: options.host === '0.0.0.0' ? 'localhost' : options.host,\n            port: buildEvent.port,\n            pathname: typeof publicPath === 'string' ? publicPath : undefined,\n          });\n\n          if (index === 0) {\n            logger.info(\n              '\\n' +\n                tags.oneLine`\n              **\n              Angular Live Development Server is listening on ${options.host}:${buildEvent.port},\n              open your browser on ${serverAddress}\n              **\n            ` +\n                '\\n',\n            );\n\n            if (options.open) {\n              const open = (await import('open')).default;\n              await open(serverAddress);\n            }\n          }\n\n          if (buildEvent.success) {\n            logger.info(`\\n${colors.greenBright(colors.symbols.check)} Compiled successfully.`);\n          } else {\n            logger.info(`\\n${colors.redBright(colors.symbols.cross)} Failed to compile.`);\n          }\n\n          return {\n            ...buildEvent,\n            baseUrl: serverAddress,\n            stats: generateBuildEventStats(webpackRawStats, browserOptions),\n          } as DevServerBuilderOutput;\n        }),\n      );\n    }),\n  );\n}\n\nasync function setupLocalize(\n  locale: string,\n  i18n: I18nOptions,\n  browserOptions: BrowserBuilderSchema,\n  webpackConfig: webpack.Configuration,\n  cacheOptions: NormalizedCachedOptions,\n  context: BuilderContext,\n) {\n  const localeDescription = i18n.locales[locale];\n\n  // Modify main entrypoint to include locale data\n  if (\n    localeDescription?.dataPath &&\n    typeof webpackConfig.entry === 'object' &&\n    !Array.isArray(webpackConfig.entry) &&\n    webpackConfig.entry['main']\n  ) {\n    if (Array.isArray(webpackConfig.entry['main'])) {\n      webpackConfig.entry['main'].unshift(localeDescription.dataPath);\n    } else {\n      webpackConfig.entry['main'] = [\n        localeDescription.dataPath,\n        webpackConfig.entry['main'] as string,\n      ];\n    }\n  }\n\n  let missingTranslationBehavior = browserOptions.i18nMissingTranslation || 'ignore';\n  let translation = localeDescription?.translation || {};\n\n  if (locale === i18n.sourceLocale) {\n    missingTranslationBehavior = 'ignore';\n    translation = {};\n  }\n\n  const i18nLoaderOptions = {\n    locale,\n    missingTranslationBehavior,\n    translation: i18n.shouldInline ? translation : undefined,\n    translationFiles: localeDescription?.files.map((file) =>\n      path.resolve(context.workspaceRoot, file.path),\n    ),\n  };\n\n  const i18nRule: webpack.RuleSetRule = {\n    test: /\\.[cm]?[tj]sx?$/,\n    enforce: 'post',\n    use: [\n      {\n        loader: require.resolve('../../babel/webpack-loader'),\n        options: {\n          cacheDirectory:\n            (cacheOptions.enabled && path.join(cacheOptions.path, 'babel-dev-server-i18n')) ||\n            false,\n          cacheIdentifier: JSON.stringify({\n            locale,\n            translationIntegrity: localeDescription?.files.map((file) => file.integrity),\n          }),\n          i18n: i18nLoaderOptions,\n        },\n      },\n    ],\n  };\n\n  // Get the rules and ensure the Webpack configuration is setup properly\n  const rules = webpackConfig.module?.rules || [];\n  if (!webpackConfig.module) {\n    webpackConfig.module = { rules };\n  } else if (!webpackConfig.module.rules) {\n    webpackConfig.module.rules = rules;\n  }\n\n  rules.push(i18nRule);\n\n  // Add a plugin to reload translation files on rebuilds\n  const loader = await createTranslationLoader();\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  webpackConfig.plugins!.push({\n    apply: (compiler: webpack.Compiler) => {\n      compiler.hooks.thisCompilation.tap('build-angular', (compilation) => {\n        if (i18n.shouldInline && i18nLoaderOptions.translation === undefined) {\n          // Reload translations\n          loadTranslations(\n            locale,\n            localeDescription,\n            context.workspaceRoot,\n            loader,\n            {\n              warn(message) {\n                addWarning(compilation, message);\n              },\n              error(message) {\n                addError(compilation, message);\n              },\n            },\n            undefined,\n            browserOptions.i18nDuplicateTranslation,\n          );\n\n          i18nLoaderOptions.translation = localeDescription.translation ?? {};\n        }\n\n        compilation.hooks.finishModules.tap('build-angular', () => {\n          // After loaders are finished, clear out the now unneeded translations\n          i18nLoaderOptions.translation = undefined;\n        });\n      });\n    },\n  });\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/extract-i18n/empty-loader.d.ts b/artifacts/build-angular/src/builders/extract-i18n/empty-loader.d.ts new file mode 100644 index 00000000..91d56010 --- /dev/null +++ b/artifacts/build-angular/src/builders/extract-i18n/empty-loader.d.ts @@ -0,0 +1,8 @@ +/** + * @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 + */ +export default function (): string; diff --git a/artifacts/build-angular/src/builders/extract-i18n/empty-loader.js b/artifacts/build-angular/src/builders/extract-i18n/empty-loader.js new file mode 100644 index 00000000..48d66413 --- /dev/null +++ b/artifacts/build-angular/src/builders/extract-i18n/empty-loader.js @@ -0,0 +1,14 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +function default_1() { + return `export default '';`; +} +exports.default = default_1; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW1wdHktbG9hZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvYW5ndWxhcl9kZXZraXQvYnVpbGRfYW5ndWxhci9zcmMvYnVpbGRlcnMvZXh0cmFjdC1pMThuL2VtcHR5LWxvYWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7OztHQU1HOztBQUVIO0lBQ0UsT0FBTyxvQkFBb0IsQ0FBQztBQUM5QixDQUFDO0FBRkQsNEJBRUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gKCkge1xuICByZXR1cm4gYGV4cG9ydCBkZWZhdWx0ICcnO2A7XG59XG4iXX0= \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/extract-i18n/index.d.ts b/artifacts/build-angular/src/builders/extract-i18n/index.d.ts new file mode 100644 index 00000000..9f7e9e6e --- /dev/null +++ b/artifacts/build-angular/src/builders/extract-i18n/index.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 { BuildResult } from '@angular-devkit/build-webpack'; +import { JsonObject } from '@angular-devkit/core'; +import webpack from 'webpack'; +import { ExecutionTransformer } from '../../transforms'; +import { Schema } from './schema'; +export type ExtractI18nBuilderOptions = Schema; +/** + * @experimental Direct usage of this function is considered experimental. + */ +export declare function execute(options: ExtractI18nBuilderOptions, context: BuilderContext, transforms?: { + webpackConfiguration?: ExecutionTransformer; +}): Promise; +declare const _default: import("../../../../architect/src/internal").Builder; +export default _default; diff --git a/artifacts/build-angular/src/builders/extract-i18n/index.js b/artifacts/build-angular/src/builders/extract-i18n/index.js new file mode 100644 index 00000000..07e3a39c --- /dev/null +++ b/artifacts/build-angular/src/builders/extract-i18n/index.js @@ -0,0 +1,258 @@ +"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; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.execute = void 0; +const architect_1 = require("@angular-devkit/architect"); +const build_webpack_1 = require("@angular-devkit/build-webpack"); +const fs = __importStar(require("fs")); +const path = __importStar(require("path")); +const rxjs_1 = require("rxjs"); +const webpack_1 = __importDefault(require("webpack")); +const i18n_options_1 = require("../../utils/i18n-options"); +const load_esm_1 = require("../../utils/load-esm"); +const purge_cache_1 = require("../../utils/purge-cache"); +const version_1 = require("../../utils/version"); +const webpack_browser_config_1 = require("../../utils/webpack-browser-config"); +const configs_1 = require("../../webpack/configs"); +const stats_1 = require("../../webpack/utils/stats"); +const schema_1 = require("../browser/schema"); +const schema_2 = require("./schema"); +function getI18nOutfile(format) { + switch (format) { + case 'xmb': + return 'messages.xmb'; + case 'xlf': + case 'xlif': + case 'xliff': + case 'xlf2': + case 'xliff2': + return 'messages.xlf'; + case 'json': + case 'legacy-migrate': + return 'messages.json'; + case 'arb': + return 'messages.arb'; + default: + throw new Error(`Unsupported format "${format}"`); + } +} +async function getSerializer(localizeToolsModule, format, sourceLocale, basePath, useLegacyIds, diagnostics) { + const { XmbTranslationSerializer, LegacyMessageIdMigrationSerializer, ArbTranslationSerializer, Xliff1TranslationSerializer, Xliff2TranslationSerializer, SimpleJsonTranslationSerializer, } = localizeToolsModule; + switch (format) { + case schema_2.Format.Xmb: + // eslint-disable-next-line @typescript-eslint/no-explicit-any + return new XmbTranslationSerializer(basePath, useLegacyIds); + case schema_2.Format.Xlf: + case schema_2.Format.Xlif: + case schema_2.Format.Xliff: + // eslint-disable-next-line @typescript-eslint/no-explicit-any + return new Xliff1TranslationSerializer(sourceLocale, basePath, useLegacyIds, {}); + case schema_2.Format.Xlf2: + case schema_2.Format.Xliff2: + // eslint-disable-next-line @typescript-eslint/no-explicit-any + return new Xliff2TranslationSerializer(sourceLocale, basePath, useLegacyIds, {}); + case schema_2.Format.Json: + return new SimpleJsonTranslationSerializer(sourceLocale); + case schema_2.Format.LegacyMigrate: + return new LegacyMessageIdMigrationSerializer(diagnostics); + case schema_2.Format.Arb: + const fileSystem = { + relative(from, to) { + return path.relative(from, to); + }, + }; + // eslint-disable-next-line @typescript-eslint/no-explicit-any + return new ArbTranslationSerializer(sourceLocale, basePath, fileSystem); + } +} +function normalizeFormatOption(options) { + let format = options.format; + switch (format) { + case schema_2.Format.Xlf: + case schema_2.Format.Xlif: + case schema_2.Format.Xliff: + format = schema_2.Format.Xlf; + break; + case schema_2.Format.Xlf2: + case schema_2.Format.Xliff2: + format = schema_2.Format.Xlf2; + break; + } + // Default format is xliff1 + return format ?? schema_2.Format.Xlf; +} +class NoEmitPlugin { + apply(compiler) { + compiler.hooks.shouldEmit.tap('angular-no-emit', () => false); + } +} +/** + * @experimental Direct usage of this function is considered experimental. + */ +async function execute(options, context, transforms) { + // Check Angular version. + (0, version_1.assertCompatibleAngularVersion)(context.workspaceRoot); + // Purge old build disk cache. + await (0, purge_cache_1.purgeStaleBuildCache)(context); + const browserTarget = (0, architect_1.targetFromTargetString)(options.browserTarget); + const browserOptions = await context.validateOptions(await context.getTargetOptions(browserTarget), await context.getBuilderNameForTarget(browserTarget)); + const format = normalizeFormatOption(options); + // We need to determine the outFile name so that AngularCompiler can retrieve it. + let outFile = options.outFile || getI18nOutfile(format); + if (options.outputPath) { + // AngularCompilerPlugin doesn't support genDir so we have to adjust outFile instead. + outFile = path.join(options.outputPath, outFile); + } + outFile = path.resolve(context.workspaceRoot, outFile); + if (!context.target || !context.target.project) { + throw new Error('The builder requires a target.'); + } + try { + require.resolve('@angular/localize'); + } + catch { + return { + success: false, + error: `i18n extraction requires the '@angular/localize' package.`, + outputPath: outFile, + }; + } + const metadata = await context.getProjectMetadata(context.target); + const i18n = (0, i18n_options_1.createI18nOptions)(metadata); + let useLegacyIds = true; + const ivyMessages = []; + const builderOptions = { + ...browserOptions, + optimization: false, + sourceMap: { + scripts: true, + styles: false, + vendor: true, + }, + buildOptimizer: false, + aot: true, + progress: options.progress, + budgets: [], + assets: [], + scripts: [], + styles: [], + deleteOutputPath: false, + extractLicenses: false, + subresourceIntegrity: false, + outputHashing: schema_1.OutputHashing.None, + namedChunks: true, + allowedCommonJsDependencies: undefined, + }; + const { config, projectRoot } = await (0, webpack_browser_config_1.generateBrowserWebpackConfigFromContext)(builderOptions, context, (wco) => { + // Default value for legacy message ids is currently true + useLegacyIds = wco.tsConfig.options.enableI18nLegacyMessageIdFormat ?? true; + const partials = [ + { plugins: [new NoEmitPlugin()] }, + (0, configs_1.getCommonConfig)(wco), + ]; + // Add Ivy application file extractor support + partials.unshift({ + module: { + rules: [ + { + test: /\.[cm]?[tj]sx?$/, + loader: require.resolve('./ivy-extract-loader'), + options: { + messageHandler: (messages) => ivyMessages.push(...messages), + }, + }, + ], + }, + }); + // Replace all stylesheets with empty content + partials.push({ + module: { + rules: [ + { + test: /\.(css|scss|sass|less)$/, + loader: require.resolve('./empty-loader'), + }, + ], + }, + }); + return partials; + }, + // During extraction we don't need specific browser support. + { supportedBrowsers: undefined }); + // All the localize usages are setup to first try the ESM entry point then fallback to the deep imports. + // This provides interim compatibility while the framework is transitioned to bundled ESM packages. + const localizeToolsModule = await (0, load_esm_1.loadEsmModule)('@angular/localize/tools'); + const webpackResult = await (0, rxjs_1.lastValueFrom)((0, build_webpack_1.runWebpack)((await transforms?.webpackConfiguration?.(config)) || config, context, { + logging: (0, stats_1.createWebpackLoggingCallback)(builderOptions, context.logger), + webpackFactory: webpack_1.default, + })); + // Set the outputPath to the extraction output location for downstream consumers + webpackResult.outputPath = outFile; + // Complete if Webpack build failed + if (!webpackResult.success) { + return webpackResult; + } + const basePath = config.context || projectRoot; + const { checkDuplicateMessages } = localizeToolsModule; + // The filesystem is used to create a relative path for each file + // from the basePath. This relative path is then used in the error message. + const checkFileSystem = { + relative(from, to) { + return path.relative(from, to); + }, + }; + const diagnostics = checkDuplicateMessages( + // eslint-disable-next-line @typescript-eslint/no-explicit-any + checkFileSystem, ivyMessages, 'warning', + // eslint-disable-next-line @typescript-eslint/no-explicit-any + basePath); + if (diagnostics.messages.length > 0) { + context.logger.warn(diagnostics.formatDiagnostics('')); + } + // Serialize all extracted messages + const serializer = await getSerializer(localizeToolsModule, format, i18n.sourceLocale, basePath, useLegacyIds, diagnostics); + const content = serializer.serialize(ivyMessages); + // Ensure directory exists + const outputPath = path.dirname(outFile); + if (!fs.existsSync(outputPath)) { + fs.mkdirSync(outputPath, { recursive: true }); + } + // Write translation file + fs.writeFileSync(outFile, content); + return webpackResult; +} +exports.execute = execute; +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/extract-i18n/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 type { ɵParsedMessage as LocalizeMessage } from '@angular/localize';\nimport type { Diagnostics } from '@angular/localize/tools';\nimport { BuilderContext, createBuilder, targetFromTargetString } from '@angular-devkit/architect';\nimport { BuildResult, runWebpack } from '@angular-devkit/build-webpack';\nimport { JsonObject } from '@angular-devkit/core';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { lastValueFrom } from 'rxjs';\nimport webpack, { Configuration } from 'webpack';\nimport { ExecutionTransformer } from '../../transforms';\nimport { createI18nOptions } from '../../utils/i18n-options';\nimport { loadEsmModule } from '../../utils/load-esm';\nimport { purgeStaleBuildCache } from '../../utils/purge-cache';\nimport { assertCompatibleAngularVersion } from '../../utils/version';\nimport { generateBrowserWebpackConfigFromContext } from '../../utils/webpack-browser-config';\nimport { getCommonConfig } from '../../webpack/configs';\nimport { createWebpackLoggingCallback } from '../../webpack/utils/stats';\nimport { Schema as BrowserBuilderOptions, OutputHashing } from '../browser/schema';\nimport { Format, Schema } from './schema';\n\nexport type ExtractI18nBuilderOptions = Schema;\n\nfunction getI18nOutfile(format: string | undefined) {\n  switch (format) {\n    case 'xmb':\n      return 'messages.xmb';\n    case 'xlf':\n    case 'xlif':\n    case 'xliff':\n    case 'xlf2':\n    case 'xliff2':\n      return 'messages.xlf';\n    case 'json':\n    case 'legacy-migrate':\n      return 'messages.json';\n    case 'arb':\n      return 'messages.arb';\n    default:\n      throw new Error(`Unsupported format \"${format}\"`);\n  }\n}\n\nasync function getSerializer(\n  localizeToolsModule: typeof import('@angular/localize/tools'),\n  format: Format,\n  sourceLocale: string,\n  basePath: string,\n  useLegacyIds: boolean,\n  diagnostics: Diagnostics,\n) {\n  const {\n    XmbTranslationSerializer,\n    LegacyMessageIdMigrationSerializer,\n    ArbTranslationSerializer,\n    Xliff1TranslationSerializer,\n    Xliff2TranslationSerializer,\n    SimpleJsonTranslationSerializer,\n  } = localizeToolsModule;\n\n  switch (format) {\n    case Format.Xmb:\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      return new XmbTranslationSerializer(basePath as any, useLegacyIds);\n    case Format.Xlf:\n    case Format.Xlif:\n    case Format.Xliff:\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      return new Xliff1TranslationSerializer(sourceLocale, basePath as any, useLegacyIds, {});\n    case Format.Xlf2:\n    case Format.Xliff2:\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      return new Xliff2TranslationSerializer(sourceLocale, basePath as any, useLegacyIds, {});\n    case Format.Json:\n      return new SimpleJsonTranslationSerializer(sourceLocale);\n    case Format.LegacyMigrate:\n      return new LegacyMessageIdMigrationSerializer(diagnostics);\n    case Format.Arb:\n      const fileSystem = {\n        relative(from: string, to: string): string {\n          return path.relative(from, to);\n        },\n      };\n\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      return new ArbTranslationSerializer(sourceLocale, basePath as any, fileSystem as any);\n  }\n}\n\nfunction normalizeFormatOption(options: ExtractI18nBuilderOptions): Format {\n  let format = options.format;\n\n  switch (format) {\n    case Format.Xlf:\n    case Format.Xlif:\n    case Format.Xliff:\n      format = Format.Xlf;\n      break;\n    case Format.Xlf2:\n    case Format.Xliff2:\n      format = Format.Xlf2;\n      break;\n  }\n\n  // Default format is xliff1\n  return format ?? Format.Xlf;\n}\n\nclass NoEmitPlugin {\n  apply(compiler: webpack.Compiler): void {\n    compiler.hooks.shouldEmit.tap('angular-no-emit', () => false);\n  }\n}\n\n/**\n * @experimental Direct usage of this function is considered experimental.\n */\nexport async function execute(\n  options: ExtractI18nBuilderOptions,\n  context: BuilderContext,\n  transforms?: {\n    webpackConfiguration?: ExecutionTransformer<webpack.Configuration>;\n  },\n): Promise<BuildResult> {\n  // Check Angular version.\n  assertCompatibleAngularVersion(context.workspaceRoot);\n\n  // Purge old build disk cache.\n  await purgeStaleBuildCache(context);\n\n  const browserTarget = targetFromTargetString(options.browserTarget);\n  const browserOptions = await context.validateOptions<JsonObject & BrowserBuilderOptions>(\n    await context.getTargetOptions(browserTarget),\n    await context.getBuilderNameForTarget(browserTarget),\n  );\n\n  const format = normalizeFormatOption(options);\n\n  // We need to determine the outFile name so that AngularCompiler can retrieve it.\n  let outFile = options.outFile || getI18nOutfile(format);\n  if (options.outputPath) {\n    // AngularCompilerPlugin doesn't support genDir so we have to adjust outFile instead.\n    outFile = path.join(options.outputPath, outFile);\n  }\n  outFile = path.resolve(context.workspaceRoot, outFile);\n\n  if (!context.target || !context.target.project) {\n    throw new Error('The builder requires a target.');\n  }\n\n  try {\n    require.resolve('@angular/localize');\n  } catch {\n    return {\n      success: false,\n      error: `i18n extraction requires the '@angular/localize' package.`,\n      outputPath: outFile,\n    };\n  }\n\n  const metadata = await context.getProjectMetadata(context.target);\n  const i18n = createI18nOptions(metadata);\n\n  let useLegacyIds = true;\n\n  const ivyMessages: LocalizeMessage[] = [];\n  const builderOptions = {\n    ...browserOptions,\n    optimization: false,\n    sourceMap: {\n      scripts: true,\n      styles: false,\n      vendor: true,\n    },\n    buildOptimizer: false,\n    aot: true,\n    progress: options.progress,\n    budgets: [],\n    assets: [],\n    scripts: [],\n    styles: [],\n    deleteOutputPath: false,\n    extractLicenses: false,\n    subresourceIntegrity: false,\n    outputHashing: OutputHashing.None,\n    namedChunks: true,\n    allowedCommonJsDependencies: undefined,\n  };\n  const { config, projectRoot } = await generateBrowserWebpackConfigFromContext(\n    builderOptions,\n    context,\n    (wco) => {\n      // Default value for legacy message ids is currently true\n      useLegacyIds = wco.tsConfig.options.enableI18nLegacyMessageIdFormat ?? true;\n\n      const partials: (Promise<Configuration> | Configuration)[] = [\n        { plugins: [new NoEmitPlugin()] },\n        getCommonConfig(wco),\n      ];\n\n      // Add Ivy application file extractor support\n      partials.unshift({\n        module: {\n          rules: [\n            {\n              test: /\\.[cm]?[tj]sx?$/,\n              loader: require.resolve('./ivy-extract-loader'),\n              options: {\n                messageHandler: (messages: LocalizeMessage[]) => ivyMessages.push(...messages),\n              },\n            },\n          ],\n        },\n      });\n\n      // Replace all stylesheets with empty content\n      partials.push({\n        module: {\n          rules: [\n            {\n              test: /\\.(css|scss|sass|less)$/,\n              loader: require.resolve('./empty-loader'),\n            },\n          ],\n        },\n      });\n\n      return partials;\n    },\n    // During extraction we don't need specific browser support.\n    { supportedBrowsers: undefined },\n  );\n\n  // All the localize usages are setup to first try the ESM entry point then fallback to the deep imports.\n  // This provides interim compatibility while the framework is transitioned to bundled ESM packages.\n  const localizeToolsModule = await loadEsmModule<typeof import('@angular/localize/tools')>(\n    '@angular/localize/tools',\n  );\n  const webpackResult = await lastValueFrom(\n    runWebpack((await transforms?.webpackConfiguration?.(config)) || config, context, {\n      logging: createWebpackLoggingCallback(builderOptions, context.logger),\n      webpackFactory: webpack,\n    }),\n  );\n\n  // Set the outputPath to the extraction output location for downstream consumers\n  webpackResult.outputPath = outFile;\n\n  // Complete if Webpack build failed\n  if (!webpackResult.success) {\n    return webpackResult;\n  }\n\n  const basePath = config.context || projectRoot;\n\n  const { checkDuplicateMessages } = localizeToolsModule;\n\n  // The filesystem is used to create a relative path for each file\n  // from the basePath.  This relative path is then used in the error message.\n  const checkFileSystem = {\n    relative(from: string, to: string): string {\n      return path.relative(from, to);\n    },\n  };\n  const diagnostics = checkDuplicateMessages(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    checkFileSystem as any,\n    ivyMessages,\n    'warning',\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    basePath as any,\n  );\n  if (diagnostics.messages.length > 0) {\n    context.logger.warn(diagnostics.formatDiagnostics(''));\n  }\n\n  // Serialize all extracted messages\n  const serializer = await getSerializer(\n    localizeToolsModule,\n    format,\n    i18n.sourceLocale,\n    basePath,\n    useLegacyIds,\n    diagnostics,\n  );\n  const content = serializer.serialize(ivyMessages);\n\n  // Ensure directory exists\n  const outputPath = path.dirname(outFile);\n  if (!fs.existsSync(outputPath)) {\n    fs.mkdirSync(outputPath, { recursive: true });\n  }\n\n  // Write translation file\n  fs.writeFileSync(outFile, content);\n\n  return webpackResult;\n}\n\nexport default createBuilder<ExtractI18nBuilderOptions>(execute);\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/extract-i18n/ivy-extract-loader.d.ts b/artifacts/build-angular/src/builders/extract-i18n/ivy-extract-loader.d.ts new file mode 100644 index 00000000..9bab2bea --- /dev/null +++ b/artifacts/build-angular/src/builders/extract-i18n/ivy-extract-loader.d.ts @@ -0,0 +1,13 @@ +/** + * @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 + */ +type LoaderSourceMap = Parameters[1]; +interface LocalizeExtractLoaderOptions { + messageHandler: (messages: import('@angular/localize').ɵParsedMessage[]) => void; +} +export default function localizeExtractLoader(this: import('webpack').LoaderContext, content: string, map: LoaderSourceMap): void; +export {}; diff --git a/artifacts/build-angular/src/builders/extract-i18n/ivy-extract-loader.js b/artifacts/build-angular/src/builders/extract-i18n/ivy-extract-loader.js new file mode 100644 index 00000000..23fe3043 --- /dev/null +++ b/artifacts/build-angular/src/builders/extract-i18n/ivy-extract-loader.js @@ -0,0 +1,128 @@ +"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 }); +const nodePath = __importStar(require("path")); +const load_esm_1 = require("../../utils/load-esm"); +function localizeExtractLoader(content, map) { + // This loader is not cacheable due to how message extraction works. + // Extracted messages are not part of webpack pipeline and hence they cannot be retrieved from cache. + // TODO: We should investigate in the future on making this deterministic and more cacheable. + this.cacheable(false); + const options = this.getOptions(); + const callback = this.async(); + extract(this, content, map, options).then(() => { + // Pass through the original content now that messages have been extracted + callback(undefined, content, map); + }, (error) => { + callback(error); + }); +} +exports.default = localizeExtractLoader; +async function extract(loaderContext, content, map, options) { + // Try to load the `@angular/localize` message extractor. + // All the localize usages are setup to first try the ESM entry point then fallback to the deep imports. + // This provides interim compatibility while the framework is transitioned to bundled ESM packages. + let MessageExtractor; + try { + // Load ESM `@angular/localize/tools` using the TypeScript dynamic import workaround. + // Once TypeScript provides support for keeping the dynamic import this workaround can be + // changed to a direct dynamic import. + const localizeToolsModule = await (0, load_esm_1.loadEsmModule)('@angular/localize/tools'); + MessageExtractor = localizeToolsModule.MessageExtractor; + } + catch { + throw new Error(`Unable to load message extractor. Please ensure '@angular/localize' is installed.`); + } + // Setup a Webpack-based logger instance + const logger = { + // level 2 is warnings + level: 2, + debug(...args) { + // eslint-disable-next-line no-console + console.debug(...args); + }, + info(...args) { + loaderContext.emitWarning(new Error(args.join(''))); + }, + warn(...args) { + loaderContext.emitWarning(new Error(args.join(''))); + }, + error(...args) { + loaderContext.emitError(new Error(args.join(''))); + }, + }; + let filename = loaderContext.resourcePath; + const mapObject = typeof map === 'string' ? JSON.parse(map) : map; + if (mapObject?.file) { + // The extractor's internal sourcemap handling expects the filenames to match + filename = nodePath.join(loaderContext.context, mapObject.file); + } + // Setup a virtual file system instance for the extractor + // * MessageExtractor itself uses readFile, relative and resolve + // * Internal SourceFileLoader (sourcemap support) uses dirname, exists, readFile, and resolve + const filesystem = { + readFile(path) { + if (path === filename) { + return content; + } + else if (path === filename + '.map') { + return typeof map === 'string' ? map : JSON.stringify(map); + } + else { + throw new Error('Unknown file requested: ' + path); + } + }, + relative(from, to) { + return nodePath.relative(from, to); + }, + resolve(...paths) { + return nodePath.resolve(...paths); + }, + exists(path) { + return path === filename || path === filename + '.map'; + }, + dirname(path) { + return nodePath.dirname(path); + }, + }; + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const extractor = new MessageExtractor(filesystem, logger, { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + basePath: loaderContext.rootContext, + useSourceMaps: !!map, + }); + const messages = extractor.extractMessages(filename); + if (messages.length > 0) { + options?.messageHandler(messages); + } +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ivy-extract-loader.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/extract-i18n/ivy-extract-loader.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 * as nodePath from 'path';\nimport { loadEsmModule } from '../../utils/load-esm';\n\n// Extract loader source map parameter type since it is not exported directly\ntype LoaderSourceMap = Parameters<import('webpack').LoaderDefinitionFunction>[1];\n\ninterface LocalizeExtractLoaderOptions {\n  messageHandler: (messages: import('@angular/localize').ɵParsedMessage[]) => void;\n}\n\nexport default function localizeExtractLoader(\n  this: import('webpack').LoaderContext<LocalizeExtractLoaderOptions>,\n  content: string,\n  map: LoaderSourceMap,\n) {\n  // This loader is not cacheable due to how message extraction works.\n  // Extracted messages are not part of webpack pipeline and hence they cannot be retrieved from cache.\n  // TODO: We should investigate in the future on making this deterministic and more cacheable.\n  this.cacheable(false);\n\n  const options = this.getOptions();\n  const callback = this.async();\n\n  extract(this, content, map, options).then(\n    () => {\n      // Pass through the original content now that messages have been extracted\n      callback(undefined, content, map);\n    },\n    (error) => {\n      callback(error);\n    },\n  );\n}\n\nasync function extract(\n  loaderContext: import('webpack').LoaderContext<LocalizeExtractLoaderOptions>,\n  content: string,\n  map: string | LoaderSourceMap | undefined,\n  options: LocalizeExtractLoaderOptions,\n) {\n  // Try to load the `@angular/localize` message extractor.\n  // All the localize usages are setup to first try the ESM entry point then fallback to the deep imports.\n  // This provides interim compatibility while the framework is transitioned to bundled ESM packages.\n  let MessageExtractor;\n  try {\n    // Load ESM `@angular/localize/tools` using the TypeScript dynamic import workaround.\n    // Once TypeScript provides support for keeping the dynamic import this workaround can be\n    // changed to a direct dynamic import.\n    const localizeToolsModule = await loadEsmModule<typeof import('@angular/localize/tools')>(\n      '@angular/localize/tools',\n    );\n    MessageExtractor = localizeToolsModule.MessageExtractor;\n  } catch {\n    throw new Error(\n      `Unable to load message extractor. Please ensure '@angular/localize' is installed.`,\n    );\n  }\n\n  // Setup a Webpack-based logger instance\n  const logger = {\n    // level 2 is warnings\n    level: 2,\n    debug(...args: string[]): void {\n      // eslint-disable-next-line no-console\n      console.debug(...args);\n    },\n    info(...args: string[]): void {\n      loaderContext.emitWarning(new Error(args.join('')));\n    },\n    warn(...args: string[]): void {\n      loaderContext.emitWarning(new Error(args.join('')));\n    },\n    error(...args: string[]): void {\n      loaderContext.emitError(new Error(args.join('')));\n    },\n  };\n\n  let filename = loaderContext.resourcePath;\n  const mapObject =\n    typeof map === 'string' ? (JSON.parse(map) as Exclude<LoaderSourceMap, string>) : map;\n  if (mapObject?.file) {\n    // The extractor's internal sourcemap handling expects the filenames to match\n    filename = nodePath.join(loaderContext.context, mapObject.file);\n  }\n\n  // Setup a virtual file system instance for the extractor\n  // * MessageExtractor itself uses readFile, relative and resolve\n  // * Internal SourceFileLoader (sourcemap support) uses dirname, exists, readFile, and resolve\n  const filesystem = {\n    readFile(path: string): string {\n      if (path === filename) {\n        return content;\n      } else if (path === filename + '.map') {\n        return typeof map === 'string' ? map : JSON.stringify(map);\n      } else {\n        throw new Error('Unknown file requested: ' + path);\n      }\n    },\n    relative(from: string, to: string): string {\n      return nodePath.relative(from, to);\n    },\n    resolve(...paths: string[]): string {\n      return nodePath.resolve(...paths);\n    },\n    exists(path: string): boolean {\n      return path === filename || path === filename + '.map';\n    },\n    dirname(path: string): string {\n      return nodePath.dirname(path);\n    },\n  };\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const extractor = new MessageExtractor(filesystem as any, logger, {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    basePath: loaderContext.rootContext as any,\n    useSourceMaps: !!map,\n  });\n\n  const messages = extractor.extractMessages(filename);\n  if (messages.length > 0) {\n    options?.messageHandler(messages);\n  }\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/extract-i18n/schema.d.ts b/artifacts/build-angular/src/builders/extract-i18n/schema.d.ts new file mode 100644 index 00000000..ff459731 --- /dev/null +++ b/artifacts/build-angular/src/builders/extract-i18n/schema.d.ts @@ -0,0 +1,41 @@ +/** + * Extract i18n target options for Build Facade. + */ +export interface Schema { + /** + * A browser builder target to extract i18n messages in the format of + * `project:target[:configuration]`. You can also pass in more than one configuration name + * as a comma-separated list. Example: `project:target:production,staging`. + */ + browserTarget: string; + /** + * Output format for the generated file. + */ + format?: Format; + /** + * Name of the file to output. + */ + outFile?: string; + /** + * Path where output will be placed. + */ + outputPath?: string; + /** + * Log progress to the console. + */ + progress?: boolean; +} +/** + * Output format for the generated file. + */ +export declare enum Format { + Arb = "arb", + Json = "json", + LegacyMigrate = "legacy-migrate", + Xlf = "xlf", + Xlf2 = "xlf2", + Xlif = "xlif", + Xliff = "xliff", + Xliff2 = "xliff2", + Xmb = "xmb" +} diff --git a/artifacts/build-angular/src/builders/extract-i18n/schema.js b/artifacts/build-angular/src/builders/extract-i18n/schema.js new file mode 100644 index 00000000..994d6b01 --- /dev/null +++ b/artifacts/build-angular/src/builders/extract-i18n/schema.js @@ -0,0 +1,21 @@ +"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 }); +exports.Format = void 0; +/** + * Output format for the generated file. + */ +var Format; +(function (Format) { + Format["Arb"] = "arb"; + Format["Json"] = "json"; + Format["LegacyMigrate"] = "legacy-migrate"; + Format["Xlf"] = "xlf"; + Format["Xlf2"] = "xlf2"; + Format["Xlif"] = "xlif"; + Format["Xliff"] = "xliff"; + Format["Xliff2"] = "xliff2"; + Format["Xmb"] = "xmb"; +})(Format = exports.Format || (exports.Format = {})); +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/extract-i18n/schema.json b/artifacts/build-angular/src/builders/extract-i18n/schema.json new file mode 100644 index 00000000..f4bf78ba --- /dev/null +++ b/artifacts/build-angular/src/builders/extract-i18n/schema.json @@ -0,0 +1,34 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema", + "title": "Extract i18n Target", + "description": "Extract i18n target options for Build Facade.", + "type": "object", + "properties": { + "browserTarget": { + "type": "string", + "description": "A browser builder target to extract i18n messages in the format of `project:target[:configuration]`. You can also pass in more than one configuration name as a comma-separated list. Example: `project:target:production,staging`.", + "pattern": "^[^:\\s]+:[^:\\s]+(:[^\\s]+)?$" + }, + "format": { + "type": "string", + "description": "Output format for the generated file.", + "default": "xlf", + "enum": ["xmb", "xlf", "xlif", "xliff", "xlf2", "xliff2", "json", "arb", "legacy-migrate"] + }, + "progress": { + "type": "boolean", + "description": "Log progress to the console.", + "default": true + }, + "outputPath": { + "type": "string", + "description": "Path where output will be placed." + }, + "outFile": { + "type": "string", + "description": "Name of the file to output." + } + }, + "additionalProperties": false, + "required": ["browserTarget"] +} diff --git a/artifacts/build-angular/src/builders/jest/index.d.ts b/artifacts/build-angular/src/builders/jest/index.d.ts new file mode 100644 index 00000000..b58c6625 --- /dev/null +++ b/artifacts/build-angular/src/builders/jest/index.d.ts @@ -0,0 +1,11 @@ +/** + * @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 { Schema as JestBuilderSchema } from './schema'; +/** Main execution function for the Jest builder. */ +declare const _default: import("../../../../architect/src/internal").Builder; +export default _default; diff --git a/artifacts/build-angular/src/builders/jest/index.js b/artifacts/build-angular/src/builders/jest/index.js new file mode 100644 index 00000000..7a3002b3 --- /dev/null +++ b/artifacts/build-angular/src/builders/jest/index.js @@ -0,0 +1,163 @@ +"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 }); +const architect_1 = require("@angular-devkit/architect"); +const child_process_1 = require("child_process"); +const path = __importStar(require("path")); +const util_1 = require("util"); +const color_1 = require("../../utils/color"); +const browser_esbuild_1 = require("../browser-esbuild"); +const schema_1 = require("../browser-esbuild/schema"); +const options_1 = require("./options"); +const test_files_1 = require("./test-files"); +const execFile = (0, util_1.promisify)(child_process_1.execFile); +/** Main execution function for the Jest builder. */ +exports.default = (0, architect_1.createBuilder)(async (schema, context) => { + context.logger.warn('NOTE: The Jest builder is currently EXPERIMENTAL and not ready for production use.'); + const options = (0, options_1.normalizeOptions)(schema); + const testOut = 'dist/test-out'; // TODO(dgp1130): Hide in temp directory. + // Verify Jest installation and get the path to it's binary. + // We need to `node_modules/.bin/jest`, but there is no means to resolve that directly. Fortunately Jest's `package.json` exports the + // same file at `bin/jest`, so we can just resolve that instead. + const jest = resolveModule('jest/bin/jest'); + if (!jest) { + return { + success: false, + // TODO(dgp1130): Display a more accurate message for non-NPM users. + error: 'Jest is not installed, most likely you need to run `npm install jest --save-dev` in your project.', + }; + } + // Verify that JSDom is installed in the project. + const environment = resolveModule('jest-environment-jsdom'); + if (!environment) { + return { + success: false, + // TODO(dgp1130): Display a more accurate message for non-NPM users. + error: '`jest-environment-jsdom` is not installed. Install it with `npm install jest-environment-jsdom --save-dev`.', + }; + } + // Build all the test files. + const testFiles = await (0, test_files_1.findTestFiles)(options, context.workspaceRoot); + const jestGlobal = path.join(__dirname, 'jest-global.mjs'); + const initTestBed = path.join(__dirname, 'init-test-bed.mjs'); + const buildResult = await build(context, { + // Build all the test files and also the `jest-global` and `init-test-bed` scripts. + entryPoints: new Set([...testFiles, jestGlobal, initTestBed]), + tsConfig: options.tsConfig, + polyfills: options.polyfills ?? ['zone.js', 'zone.js/testing'], + outputPath: testOut, + aot: false, + index: null, + outputHashing: schema_1.OutputHashing.None, + outExtension: 'mjs', + commonChunk: false, + optimization: false, + buildOptimizer: false, + sourceMap: { + scripts: true, + styles: false, + vendor: false, + }, + }); + if (!buildResult.success) { + return buildResult; + } + // Execute Jest on the built output directory. + const jestProc = execFile(process.execPath, [ + '--experimental-vm-modules', + jest, + `--rootDir="${testOut}"`, + '--testEnvironment=jsdom', + // TODO(dgp1130): Enable cache once we have a mechanism for properly clearing / disabling it. + '--no-cache', + // Run basically all files in the output directory, any excluded files were already dropped by the build. + `--testMatch="/**/*.mjs"`, + // Load polyfills and initialize the environment before executing each test file. + // IMPORTANT: Order matters here. + // First, we execute `jest-global.mjs` to initialize the `jest` global variable. + // Second, we execute user polyfills, including `zone.js` and `zone.js/testing`. This is dependent on the Jest global so it can patch + // the environment for fake async to work correctly. + // Third, we initialize `TestBed`. This is dependent on fake async being set up correctly beforehand. + `--setupFilesAfterEnv="/jest-global.mjs"`, + ...(options.polyfills ? [`--setupFilesAfterEnv="/polyfills.mjs"`] : []), + `--setupFilesAfterEnv="/init-test-bed.mjs"`, + // Don't run any infrastructure files as tests, they are manually loaded where needed. + `--testPathIgnorePatterns="/jest-global\\.mjs"`, + ...(options.polyfills ? [`--testPathIgnorePatterns="/polyfills\\.mjs"`] : []), + `--testPathIgnorePatterns="/init-test-bed\\.mjs"`, + // Skip shared chunks, as they are not entry points to tests. + `--testPathIgnorePatterns="/chunk-.*\\.mjs"`, + // Optionally enable color. + ...(color_1.colors.enabled ? ['--colors'] : []), + ]); + // Stream test output to the terminal. + jestProc.child.stdout?.on('data', (chunk) => { + context.logger.info(chunk); + }); + jestProc.child.stderr?.on('data', (chunk) => { + // Write to stderr directly instead of `context.logger.error(chunk)` because the logger will overwrite Jest's coloring information. + process.stderr.write(chunk); + }); + try { + await jestProc; + } + catch (error) { + // No need to propagate error message, already piped to terminal output. + // TODO(dgp1130): Handle process spawning failures. + return { success: false }; + } + return { success: true }; +}); +async function build(context, options) { + try { + for await (const _ of (0, browser_esbuild_1.buildEsbuildBrowserInternal)(options, context)) { + // Nothing to do for each event, just wait for the whole build. + } + return { success: true }; + } + catch (err) { + return { + success: false, + error: err.message, + }; + } +} +/** Safely resolves the given Node module string. */ +function resolveModule(module) { + try { + return require.resolve(module); + } + catch { + return undefined; + } +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/jest/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 { BuilderContext, BuilderOutput, createBuilder } from '@angular-devkit/architect';\nimport { execFile as execFileCb } from 'child_process';\nimport * as path from 'path';\nimport { promisify } from 'util';\nimport { colors } from '../../utils/color';\nimport { buildEsbuildBrowserInternal } from '../browser-esbuild';\nimport { BrowserEsbuildOptions } from '../browser-esbuild/options';\nimport { OutputHashing } from '../browser-esbuild/schema';\nimport { normalizeOptions } from './options';\nimport { Schema as JestBuilderSchema } from './schema';\nimport { findTestFiles } from './test-files';\n\nconst execFile = promisify(execFileCb);\n\n/** Main execution function for the Jest builder. */\nexport default createBuilder(\n  async (schema: JestBuilderSchema, context: BuilderContext): Promise<BuilderOutput> => {\n    context.logger.warn(\n      'NOTE: The Jest builder is currently EXPERIMENTAL and not ready for production use.',\n    );\n\n    const options = normalizeOptions(schema);\n    const testOut = 'dist/test-out'; // TODO(dgp1130): Hide in temp directory.\n\n    // Verify Jest installation and get the path to it's binary.\n    // We need to `node_modules/.bin/jest`, but there is no means to resolve that directly. Fortunately Jest's `package.json` exports the\n    // same file at `bin/jest`, so we can just resolve that instead.\n    const jest = resolveModule('jest/bin/jest');\n    if (!jest) {\n      return {\n        success: false,\n        // TODO(dgp1130): Display a more accurate message for non-NPM users.\n        error:\n          'Jest is not installed, most likely you need to run `npm install jest --save-dev` in your project.',\n      };\n    }\n\n    // Verify that JSDom is installed in the project.\n    const environment = resolveModule('jest-environment-jsdom');\n    if (!environment) {\n      return {\n        success: false,\n        // TODO(dgp1130): Display a more accurate message for non-NPM users.\n        error:\n          '`jest-environment-jsdom` is not installed. Install it with `npm install jest-environment-jsdom --save-dev`.',\n      };\n    }\n\n    // Build all the test files.\n    const testFiles = await findTestFiles(options, context.workspaceRoot);\n    const jestGlobal = path.join(__dirname, 'jest-global.mjs');\n    const initTestBed = path.join(__dirname, 'init-test-bed.mjs');\n    const buildResult = await build(context, {\n      // Build all the test files and also the `jest-global` and `init-test-bed` scripts.\n      entryPoints: new Set([...testFiles, jestGlobal, initTestBed]),\n      tsConfig: options.tsConfig,\n      polyfills: options.polyfills ?? ['zone.js', 'zone.js/testing'],\n      outputPath: testOut,\n      aot: false,\n      index: null,\n      outputHashing: OutputHashing.None,\n      outExtension: 'mjs', // Force native ESM.\n      commonChunk: false,\n      optimization: false,\n      buildOptimizer: false,\n      sourceMap: {\n        scripts: true,\n        styles: false,\n        vendor: false,\n      },\n    });\n    if (!buildResult.success) {\n      return buildResult;\n    }\n\n    // Execute Jest on the built output directory.\n    const jestProc = execFile(process.execPath, [\n      '--experimental-vm-modules',\n      jest,\n\n      `--rootDir=\"${testOut}\"`,\n      '--testEnvironment=jsdom',\n\n      // TODO(dgp1130): Enable cache once we have a mechanism for properly clearing / disabling it.\n      '--no-cache',\n\n      // Run basically all files in the output directory, any excluded files were already dropped by the build.\n      `--testMatch=\"<rootDir>/**/*.mjs\"`,\n\n      // Load polyfills and initialize the environment before executing each test file.\n      // IMPORTANT: Order matters here.\n      // First, we execute `jest-global.mjs` to initialize the `jest` global variable.\n      // Second, we execute user polyfills, including `zone.js` and `zone.js/testing`. This is dependent on the Jest global so it can patch\n      // the environment for fake async to work correctly.\n      // Third, we initialize `TestBed`. This is dependent on fake async being set up correctly beforehand.\n      `--setupFilesAfterEnv=\"<rootDir>/jest-global.mjs\"`,\n      ...(options.polyfills ? [`--setupFilesAfterEnv=\"<rootDir>/polyfills.mjs\"`] : []),\n      `--setupFilesAfterEnv=\"<rootDir>/init-test-bed.mjs\"`,\n\n      // Don't run any infrastructure files as tests, they are manually loaded where needed.\n      `--testPathIgnorePatterns=\"<rootDir>/jest-global\\\\.mjs\"`,\n      ...(options.polyfills ? [`--testPathIgnorePatterns=\"<rootDir>/polyfills\\\\.mjs\"`] : []),\n      `--testPathIgnorePatterns=\"<rootDir>/init-test-bed\\\\.mjs\"`,\n\n      // Skip shared chunks, as they are not entry points to tests.\n      `--testPathIgnorePatterns=\"<rootDir>/chunk-.*\\\\.mjs\"`,\n\n      // Optionally enable color.\n      ...(colors.enabled ? ['--colors'] : []),\n    ]);\n\n    // Stream test output to the terminal.\n    jestProc.child.stdout?.on('data', (chunk) => {\n      context.logger.info(chunk);\n    });\n    jestProc.child.stderr?.on('data', (chunk) => {\n      // Write to stderr directly instead of `context.logger.error(chunk)` because the logger will overwrite Jest's coloring information.\n      process.stderr.write(chunk);\n    });\n\n    try {\n      await jestProc;\n    } catch (error) {\n      // No need to propagate error message, already piped to terminal output.\n      // TODO(dgp1130): Handle process spawning failures.\n      return { success: false };\n    }\n\n    return { success: true };\n  },\n);\n\nasync function build(\n  context: BuilderContext,\n  options: BrowserEsbuildOptions,\n): Promise<BuilderOutput> {\n  try {\n    for await (const _ of buildEsbuildBrowserInternal(options, context)) {\n      // Nothing to do for each event, just wait for the whole build.\n    }\n\n    return { success: true };\n  } catch (err) {\n    return {\n      success: false,\n      error: (err as Error).message,\n    };\n  }\n}\n\n/** Safely resolves the given Node module string. */\nfunction resolveModule(module: string): string | undefined {\n  try {\n    return require.resolve(module);\n  } catch {\n    return undefined;\n  }\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/jest/init-test-bed.mjs b/artifacts/build-angular/src/builders/jest/init-test-bed.mjs new file mode 100644 index 00000000..1c5a7264 --- /dev/null +++ b/artifacts/build-angular/src/builders/jest/init-test-bed.mjs @@ -0,0 +1,18 @@ +/** + * @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 + */ + +// TODO(dgp1130): These imports likely don't resolve in stricter package environments like `pnpm`, since they are resolved relative to +// `@angular-devkit/build-angular` rather than the user's workspace. Should look into virtual modules to support those use cases. + +import { getTestBed } from '@angular/core/testing'; +import { BrowserDynamicTestingModule, platformBrowserDynamicTesting } from '@angular/platform-browser-dynamic/testing'; + +getTestBed().initTestEnvironment(BrowserDynamicTestingModule, platformBrowserDynamicTesting(), { + errorOnUnknownElements: true, + errorOnUnknownProperties: true, +}); diff --git a/artifacts/build-angular/src/builders/jest/jest-global.mjs b/artifacts/build-angular/src/builders/jest/jest-global.mjs new file mode 100644 index 00000000..6256124c --- /dev/null +++ b/artifacts/build-angular/src/builders/jest/jest-global.mjs @@ -0,0 +1,19 @@ +/** + * @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 + */ + +/** + * @fileoverview Zone.js requires the `jest` global to be initialized in order to know that it must patch the environment to support Jest + * execution. When running ESM code, Jest does _not_ inject the global `jest` symbol, so Zone.js would not normally know it is running + * within Jest as users are supposed to import from `@jest/globals` or use `import.meta.jest`. Zone.js is not currently aware of this, so we + * manually set this global to get Zone.js to run correctly. + * + * TODO(dgp1130): Update Zone.js to directly support Jest ESM executions so we can drop this. + */ + +// eslint-disable-next-line no-undef +globalThis.jest = import.meta.jest; diff --git a/artifacts/build-angular/src/builders/jest/options.d.ts b/artifacts/build-angular/src/builders/jest/options.d.ts new file mode 100644 index 00000000..c6d3a9ec --- /dev/null +++ b/artifacts/build-angular/src/builders/jest/options.d.ts @@ -0,0 +1,21 @@ +/** + * @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 { Schema as JestBuilderSchema } from './schema'; +/** + * Options supported for the Jest builder. The schema is an approximate + * representation of the options type, but this is a more precise version. + */ +export type JestBuilderOptions = JestBuilderSchema & { + include: string[]; + exclude: string[]; +}; +/** + * Normalizes input options validated by the schema to a more precise and useful + * options type in {@link JestBuilderOptions}. + */ +export declare function normalizeOptions(schema: JestBuilderSchema): JestBuilderOptions; diff --git a/artifacts/build-angular/src/builders/jest/options.js b/artifacts/build-angular/src/builders/jest/options.js new file mode 100644 index 00000000..b7af4885 --- /dev/null +++ b/artifacts/build-angular/src/builders/jest/options.js @@ -0,0 +1,26 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.normalizeOptions = void 0; +/** + * Normalizes input options validated by the schema to a more precise and useful + * options type in {@link JestBuilderOptions}. + */ +function normalizeOptions(schema) { + return { + // Options with default values can't actually be null, even if the types say so. + /* eslint-disable @typescript-eslint/no-non-null-assertion */ + include: schema.include, + exclude: schema.exclude, + /* eslint-enable @typescript-eslint/no-non-null-assertion */ + ...schema, + }; +} +exports.normalizeOptions = normalizeOptions; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/jest/schema.d.ts b/artifacts/build-angular/src/builders/jest/schema.d.ts new file mode 100644 index 00000000..093c205d --- /dev/null +++ b/artifacts/build-angular/src/builders/jest/schema.d.ts @@ -0,0 +1,25 @@ +/** + * Jest target options + */ +export interface Schema { + /** + * Globs of files to exclude, relative to the project root. + */ + exclude?: string[]; + /** + * Globs of files to include, relative to project root. + */ + include?: string[]; + /** + * Polyfills to be included in the build. + */ + polyfills?: Polyfills; + /** + * The name of the TypeScript configuration file. + */ + tsConfig: string; +} +/** + * Polyfills to be included in the build. + */ +export type Polyfills = string[] | string; diff --git a/artifacts/build-angular/src/builders/jest/schema.js b/artifacts/build-angular/src/builders/jest/schema.js new file mode 100644 index 00000000..31865e66 --- /dev/null +++ b/artifacts/build-angular/src/builders/jest/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvYW5ndWxhcl9kZXZraXQvYnVpbGRfYW5ndWxhci9zcmMvYnVpbGRlcnMvamVzdC9zY2hlbWEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUNBLG1GQUFtRjtBQUNuRixvRkFBb0YiLCJzb3VyY2VzQ29udGVudCI6WyJcbi8vIFRISVMgRklMRSBJUyBBVVRPTUFUSUNBTExZIEdFTkVSQVRFRC4gVE8gVVBEQVRFIFRISVMgRklMRSBZT1UgTkVFRCBUTyBDSEFOR0UgVEhFXG4vLyBDT1JSRVNQT05ESU5HIEpTT04gU0NIRU1BIEZJTEUsIFRIRU4gUlVOIGRldmtpdC1hZG1pbiBidWlsZCAob3IgYmF6ZWwgYnVpbGQgLi4uKS5cblxuLyoqXG4gKiBKZXN0IHRhcmdldCBvcHRpb25zXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU2NoZW1hIHtcbiAgICAvKipcbiAgICAgKiBHbG9icyBvZiBmaWxlcyB0byBleGNsdWRlLCByZWxhdGl2ZSB0byB0aGUgcHJvamVjdCByb290LlxuICAgICAqL1xuICAgIGV4Y2x1ZGU/OiBzdHJpbmdbXTtcbiAgICAvKipcbiAgICAgKiBHbG9icyBvZiBmaWxlcyB0byBpbmNsdWRlLCByZWxhdGl2ZSB0byBwcm9qZWN0IHJvb3QuXG4gICAgICovXG4gICAgaW5jbHVkZT86IHN0cmluZ1tdO1xuICAgIC8qKlxuICAgICAqIFBvbHlmaWxscyB0byBiZSBpbmNsdWRlZCBpbiB0aGUgYnVpbGQuXG4gICAgICovXG4gICAgcG9seWZpbGxzPzogUG9seWZpbGxzO1xuICAgIC8qKlxuICAgICAqIFRoZSBuYW1lIG9mIHRoZSBUeXBlU2NyaXB0IGNvbmZpZ3VyYXRpb24gZmlsZS5cbiAgICAgKi9cbiAgICB0c0NvbmZpZzogc3RyaW5nO1xufVxuXG4vKipcbiAqIFBvbHlmaWxscyB0byBiZSBpbmNsdWRlZCBpbiB0aGUgYnVpbGQuXG4gKi9cbmV4cG9ydCB0eXBlIFBvbHlmaWxscyA9IHN0cmluZ1tdIHwgc3RyaW5nO1xuIl19 \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/jest/schema.json b/artifacts/build-angular/src/builders/jest/schema.json new file mode 100644 index 00000000..049b9124 --- /dev/null +++ b/artifacts/build-angular/src/builders/jest/schema.json @@ -0,0 +1,48 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema", + "title": "Jest browser schema for Build Facade.", + "description": "Jest target options", + "type": "object", + "properties": { + "include": { + "type": "array", + "items": { + "type": "string" + }, + "default": ["**/*.spec.ts"], + "description": "Globs of files to include, relative to project root." + }, + "exclude": { + "type": "array", + "items": { + "type": "string" + }, + "default": [], + "description": "Globs of files to exclude, relative to the project root." + }, + "tsConfig": { + "type": "string", + "description": "The name of the TypeScript configuration file." + }, + "polyfills": { + "description": "Polyfills to be included in the build.", + "oneOf": [ + { + "type": "array", + "description": "A list of polyfills to include in the build. Can be a full path for a file, relative to the current workspace or module specifier. Example: 'zone.js'.", + "items": { + "type": "string", + "uniqueItems": true + }, + "default": [] + }, + { + "type": "string", + "description": "The full path for the polyfills file, relative to the current workspace or a module specifier. Example: 'zone.js'." + } + ] + } + }, + "additionalProperties": false, + "required": ["tsConfig"] +} diff --git a/artifacts/build-angular/src/builders/jest/test-files.d.ts b/artifacts/build-angular/src/builders/jest/test-files.d.ts new file mode 100644 index 00000000..354b26d9 --- /dev/null +++ b/artifacts/build-angular/src/builders/jest/test-files.d.ts @@ -0,0 +1,20 @@ +/** + * @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 { JestBuilderOptions } from './options'; +declare const globAsync: typeof import("glob").__promisify__; +/** + * Finds all test files in the project. + * + * @param options The builder options describing where to find tests. + * @param workspaceRoot The path to the root directory of the workspace. + * @param glob A promisified implementation of the `glob` module. Only intended for + * testing purposes. + * @returns A set of all test files in the project. + */ +export declare function findTestFiles(options: JestBuilderOptions, workspaceRoot: string, glob?: typeof globAsync): Promise>; +export {}; diff --git a/artifacts/build-angular/src/builders/jest/test-files.js b/artifacts/build-angular/src/builders/jest/test-files.js new file mode 100644 index 00000000..68325f60 --- /dev/null +++ b/artifacts/build-angular/src/builders/jest/test-files.js @@ -0,0 +1,37 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.findTestFiles = void 0; +const glob_1 = require("glob"); +const util_1 = require("util"); +const globAsync = (0, util_1.promisify)(glob_1.glob); +/** + * Finds all test files in the project. + * + * @param options The builder options describing where to find tests. + * @param workspaceRoot The path to the root directory of the workspace. + * @param glob A promisified implementation of the `glob` module. Only intended for + * testing purposes. + * @returns A set of all test files in the project. + */ +async function findTestFiles(options, workspaceRoot, glob = globAsync) { + const globOptions = { + cwd: workspaceRoot, + ignore: ['node_modules/**'].concat(options.exclude), + strict: true, + nobrace: true, + noext: true, + nodir: true, // Match only files, don't care about directories. + }; + const included = await Promise.all(options.include.map((pattern) => glob(pattern, globOptions))); + // Flatten and deduplicate any files found in multiple include patterns. + return new Set(included.flat()); +} +exports.findTestFiles = findTestFiles; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/karma/find-tests-plugin.d.ts b/artifacts/build-angular/src/builders/karma/find-tests-plugin.d.ts new file mode 100644 index 00000000..f11cb46f --- /dev/null +++ b/artifacts/build-angular/src/builders/karma/find-tests-plugin.d.ts @@ -0,0 +1,20 @@ +/** + * @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 type { Compiler } from 'webpack'; +export interface FindTestsPluginOptions { + include?: string[]; + exclude?: string[]; + workspaceRoot: string; + projectSourceRoot: string; +} +export declare class FindTestsPlugin { + private options; + private compilation; + constructor(options: FindTestsPluginOptions); + apply(compiler: Compiler): void; +} diff --git a/artifacts/build-angular/src/builders/karma/find-tests-plugin.js b/artifacts/build-angular/src/builders/karma/find-tests-plugin.js new file mode 100644 index 00000000..e5b2b312 --- /dev/null +++ b/artifacts/build-angular/src/builders/karma/find-tests-plugin.js @@ -0,0 +1,145 @@ +"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; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.FindTestsPlugin = void 0; +const assert_1 = __importDefault(require("assert")); +const fs_1 = require("fs"); +const glob_1 = __importStar(require("glob")); +const mini_css_extract_plugin_1 = require("mini-css-extract-plugin"); +const path_1 = require("path"); +const util_1 = require("util"); +const globPromise = (0, util_1.promisify)(glob_1.default); +/** + * The name of the plugin provided to Webpack when tapping Webpack compiler hooks. + */ +const PLUGIN_NAME = 'angular-find-tests-plugin'; +class FindTestsPlugin { + constructor(options) { + this.options = options; + } + apply(compiler) { + const { include = ['**/*.spec.ts'], exclude = [], projectSourceRoot, workspaceRoot, } = this.options; + const webpackOptions = compiler.options; + const entry = typeof webpackOptions.entry === 'function' ? webpackOptions.entry() : webpackOptions.entry; + let originalImport; + // Add tests files are part of the entry-point. + webpackOptions.entry = async () => { + const specFiles = await findTests(include, exclude, workspaceRoot, projectSourceRoot); + const entrypoints = await entry; + const entrypoint = entrypoints['main']; + if (!entrypoint.import) { + throw new Error(`Cannot find 'main' entrypoint.`); + } + if (specFiles.length) { + originalImport ?? (originalImport = entrypoint.import); + entrypoint.import = [...originalImport, ...specFiles]; + } + else { + (0, assert_1.default)(this.compilation, 'Compilation cannot be undefined.'); + this.compilation + .getLogger(mini_css_extract_plugin_1.pluginName) + .error(`Specified patterns: "${include.join(', ')}" did not match any spec files.`); + } + return entrypoints; + }; + compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => { + this.compilation = compilation; + compilation.contextDependencies.add(projectSourceRoot); + }); + } +} +exports.FindTestsPlugin = FindTestsPlugin; +// go through all patterns and find unique list of files +async function findTests(include, exclude, workspaceRoot, projectSourceRoot) { + const matchingTestsPromises = include.map((pattern) => findMatchingTests(pattern, exclude, workspaceRoot, projectSourceRoot)); + const files = await Promise.all(matchingTestsPromises); + // Unique file names + return [...new Set(files.flat())]; +} +const normalizePath = (path) => path.replace(/\\/g, '/'); +async function findMatchingTests(pattern, ignore, workspaceRoot, projectSourceRoot) { + // normalize pattern, glob lib only accepts forward slashes + let normalizedPattern = normalizePath(pattern); + if (normalizedPattern.charAt(0) === '/') { + normalizedPattern = normalizedPattern.substring(1); + } + const relativeProjectRoot = normalizePath((0, path_1.relative)(workspaceRoot, projectSourceRoot) + '/'); + // remove relativeProjectRoot to support relative paths from root + // such paths are easy to get when running scripts via IDEs + if (normalizedPattern.startsWith(relativeProjectRoot)) { + normalizedPattern = normalizedPattern.substring(relativeProjectRoot.length); + } + // special logic when pattern does not look like a glob + if (!(0, glob_1.hasMagic)(normalizedPattern)) { + if (await isDirectory((0, path_1.join)(projectSourceRoot, normalizedPattern))) { + normalizedPattern = `${normalizedPattern}/**/*.spec.@(ts|tsx)`; + } + else { + // see if matching spec file exists + const fileExt = (0, path_1.extname)(normalizedPattern); + // Replace extension to `.spec.ext`. Example: `src/app/app.component.ts`-> `src/app/app.component.spec.ts` + const potentialSpec = (0, path_1.join)(projectSourceRoot, (0, path_1.dirname)(normalizedPattern), `${(0, path_1.basename)(normalizedPattern, fileExt)}.spec${fileExt}`); + if (await exists(potentialSpec)) { + return [potentialSpec]; + } + } + } + return globPromise(normalizedPattern, { + cwd: projectSourceRoot, + root: projectSourceRoot, + nomount: true, + absolute: true, + ignore: ['**/node_modules/**', ...ignore], + }); +} +async function isDirectory(path) { + try { + const stats = await fs_1.promises.stat(path); + return stats.isDirectory(); + } + catch { + return false; + } +} +async function exists(path) { + try { + await fs_1.promises.access(path, fs_1.constants.F_OK); + return true; + } + catch { + return false; + } +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"find-tests-plugin.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/karma/find-tests-plugin.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,oDAA4B;AAC5B,2BAAyD;AACzD,6CAAsC;AACtC,qEAAqD;AACrD,+BAAkE;AAClE,+BAAiC;AAGjC,MAAM,WAAW,GAAG,IAAA,gBAAS,EAAC,cAAI,CAAC,CAAC;AAEpC;;GAEG;AACH,MAAM,WAAW,GAAG,2BAA2B,CAAC;AAShD,MAAa,eAAe;IAG1B,YAAoB,OAA+B;QAA/B,YAAO,GAAP,OAAO,CAAwB;IAAG,CAAC;IAEvD,KAAK,CAAC,QAAkB;QACtB,MAAM,EACJ,OAAO,GAAG,CAAC,cAAc,CAAC,EAC1B,OAAO,GAAG,EAAE,EACZ,iBAAiB,EACjB,aAAa,GACd,GAAG,IAAI,CAAC,OAAO,CAAC;QACjB,MAAM,cAAc,GAAG,QAAQ,CAAC,OAAO,CAAC;QACxC,MAAM,KAAK,GACT,OAAO,cAAc,CAAC,KAAK,KAAK,UAAU,CAAC,CAAC,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC;QAE7F,IAAI,cAAoC,CAAC;QAEzC,+CAA+C;QAC/C,cAAc,CAAC,KAAK,GAAG,KAAK,IAAI,EAAE;YAChC,MAAM,SAAS,GAAG,MAAM,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,iBAAiB,CAAC,CAAC;YACtF,MAAM,WAAW,GAAG,MAAM,KAAK,CAAC;YAChC,MAAM,UAAU,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;YACvC,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE;gBACtB,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;aACnD;YAED,IAAI,SAAS,CAAC,MAAM,EAAE;gBACpB,cAAc,KAAd,cAAc,GAAK,UAAU,CAAC,MAAM,EAAC;gBACrC,UAAU,CAAC,MAAM,GAAG,CAAC,GAAG,cAAc,EAAE,GAAG,SAAS,CAAC,CAAC;aACvD;iBAAM;gBACL,IAAA,gBAAM,EAAC,IAAI,CAAC,WAAW,EAAE,kCAAkC,CAAC,CAAC;gBAC7D,IAAI,CAAC,WAAW;qBACb,SAAS,CAAC,oCAAU,CAAC;qBACrB,KAAK,CAAC,wBAAwB,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,iCAAiC,CAAC,CAAC;aACvF;YAED,OAAO,WAAW,CAAC;QACrB,CAAC,CAAC;QAEF,QAAQ,CAAC,KAAK,CAAC,eAAe,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,WAAW,EAAE,EAAE;YAC9D,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;YAC/B,WAAW,CAAC,mBAAmB,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;QACzD,CAAC,CAAC,CAAC;IACL,CAAC;CACF;AA7CD,0CA6CC;AAED,wDAAwD;AACxD,KAAK,UAAU,SAAS,CACtB,OAAiB,EACjB,OAAiB,EACjB,aAAqB,EACrB,iBAAyB;IAEzB,MAAM,qBAAqB,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CACpD,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,iBAAiB,CAAC,CACtE,CAAC;IACF,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;IAEvD,oBAAoB;IACpB,OAAO,CAAC,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;AACpC,CAAC;AAED,MAAM,aAAa,GAAG,CAAC,IAAY,EAAU,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;AAEzE,KAAK,UAAU,iBAAiB,CAC9B,OAAe,EACf,MAAgB,EAChB,aAAqB,EACrB,iBAAyB;IAEzB,2DAA2D;IAC3D,IAAI,iBAAiB,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC;IAC/C,IAAI,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE;QACvC,iBAAiB,GAAG,iBAAiB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;KACpD;IAED,MAAM,mBAAmB,GAAG,aAAa,CAAC,IAAA,eAAQ,EAAC,aAAa,EAAE,iBAAiB,CAAC,GAAG,GAAG,CAAC,CAAC;IAE5F,iEAAiE;IACjE,2DAA2D;IAC3D,IAAI,iBAAiB,CAAC,UAAU,CAAC,mBAAmB,CAAC,EAAE;QACrD,iBAAiB,GAAG,iBAAiB,CAAC,SAAS,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;KAC7E;IAED,uDAAuD;IACvD,IAAI,CAAC,IAAA,eAAQ,EAAC,iBAAiB,CAAC,EAAE;QAChC,IAAI,MAAM,WAAW,CAAC,IAAA,WAAI,EAAC,iBAAiB,EAAE,iBAAiB,CAAC,CAAC,EAAE;YACjE,iBAAiB,GAAG,GAAG,iBAAiB,sBAAsB,CAAC;SAChE;aAAM;YACL,mCAAmC;YACnC,MAAM,OAAO,GAAG,IAAA,cAAO,EAAC,iBAAiB,CAAC,CAAC;YAC3C,0GAA0G;YAC1G,MAAM,aAAa,GAAG,IAAA,WAAI,EACxB,iBAAiB,EACjB,IAAA,cAAO,EAAC,iBAAiB,CAAC,EAC1B,GAAG,IAAA,eAAQ,EAAC,iBAAiB,EAAE,OAAO,CAAC,QAAQ,OAAO,EAAE,CACzD,CAAC;YAEF,IAAI,MAAM,MAAM,CAAC,aAAa,CAAC,EAAE;gBAC/B,OAAO,CAAC,aAAa,CAAC,CAAC;aACxB;SACF;KACF;IAED,OAAO,WAAW,CAAC,iBAAiB,EAAE;QACpC,GAAG,EAAE,iBAAiB;QACtB,IAAI,EAAE,iBAAiB;QACvB,OAAO,EAAE,IAAI;QACb,QAAQ,EAAE,IAAI;QACd,MAAM,EAAE,CAAC,oBAAoB,EAAE,GAAG,MAAM,CAAC;KAC1C,CAAC,CAAC;AACL,CAAC;AAED,KAAK,UAAU,WAAW,CAAC,IAAc;IACvC,IAAI;QACF,MAAM,KAAK,GAAG,MAAM,aAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAElC,OAAO,KAAK,CAAC,WAAW,EAAE,CAAC;KAC5B;IAAC,MAAM;QACN,OAAO,KAAK,CAAC;KACd;AACH,CAAC;AAED,KAAK,UAAU,MAAM,CAAC,IAAc;IAClC,IAAI;QACF,MAAM,aAAE,CAAC,MAAM,CAAC,IAAI,EAAE,cAAS,CAAC,IAAI,CAAC,CAAC;QAEtC,OAAO,IAAI,CAAC;KACb;IAAC,MAAM;QACN,OAAO,KAAK,CAAC;KACd;AACH,CAAC","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 assert from 'assert';\nimport { PathLike, constants, promises as fs } from 'fs';\nimport glob, { hasMagic } from 'glob';\nimport { pluginName } from 'mini-css-extract-plugin';\nimport { basename, dirname, extname, join, relative } from 'path';\nimport { promisify } from 'util';\nimport type { Compilation, Compiler } from 'webpack';\n\nconst globPromise = promisify(glob);\n\n/**\n * The name of the plugin provided to Webpack when tapping Webpack compiler hooks.\n */\nconst PLUGIN_NAME = 'angular-find-tests-plugin';\n\nexport interface FindTestsPluginOptions {\n  include?: string[];\n  exclude?: string[];\n  workspaceRoot: string;\n  projectSourceRoot: string;\n}\n\nexport class FindTestsPlugin {\n  private compilation: Compilation | undefined;\n\n  constructor(private options: FindTestsPluginOptions) {}\n\n  apply(compiler: Compiler): void {\n    const {\n      include = ['**/*.spec.ts'],\n      exclude = [],\n      projectSourceRoot,\n      workspaceRoot,\n    } = this.options;\n    const webpackOptions = compiler.options;\n    const entry =\n      typeof webpackOptions.entry === 'function' ? webpackOptions.entry() : webpackOptions.entry;\n\n    let originalImport: string[] | undefined;\n\n    // Add tests files are part of the entry-point.\n    webpackOptions.entry = async () => {\n      const specFiles = await findTests(include, exclude, workspaceRoot, projectSourceRoot);\n      const entrypoints = await entry;\n      const entrypoint = entrypoints['main'];\n      if (!entrypoint.import) {\n        throw new Error(`Cannot find 'main' entrypoint.`);\n      }\n\n      if (specFiles.length) {\n        originalImport ??= entrypoint.import;\n        entrypoint.import = [...originalImport, ...specFiles];\n      } else {\n        assert(this.compilation, 'Compilation cannot be undefined.');\n        this.compilation\n          .getLogger(pluginName)\n          .error(`Specified patterns: \"${include.join(', ')}\" did not match any spec files.`);\n      }\n\n      return entrypoints;\n    };\n\n    compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {\n      this.compilation = compilation;\n      compilation.contextDependencies.add(projectSourceRoot);\n    });\n  }\n}\n\n// go through all patterns and find unique list of files\nasync function findTests(\n  include: string[],\n  exclude: string[],\n  workspaceRoot: string,\n  projectSourceRoot: string,\n): Promise<string[]> {\n  const matchingTestsPromises = include.map((pattern) =>\n    findMatchingTests(pattern, exclude, workspaceRoot, projectSourceRoot),\n  );\n  const files = await Promise.all(matchingTestsPromises);\n\n  // Unique file names\n  return [...new Set(files.flat())];\n}\n\nconst normalizePath = (path: string): string => path.replace(/\\\\/g, '/');\n\nasync function findMatchingTests(\n  pattern: string,\n  ignore: string[],\n  workspaceRoot: string,\n  projectSourceRoot: string,\n): Promise<string[]> {\n  // normalize pattern, glob lib only accepts forward slashes\n  let normalizedPattern = normalizePath(pattern);\n  if (normalizedPattern.charAt(0) === '/') {\n    normalizedPattern = normalizedPattern.substring(1);\n  }\n\n  const relativeProjectRoot = normalizePath(relative(workspaceRoot, projectSourceRoot) + '/');\n\n  // remove relativeProjectRoot to support relative paths from root\n  // such paths are easy to get when running scripts via IDEs\n  if (normalizedPattern.startsWith(relativeProjectRoot)) {\n    normalizedPattern = normalizedPattern.substring(relativeProjectRoot.length);\n  }\n\n  // special logic when pattern does not look like a glob\n  if (!hasMagic(normalizedPattern)) {\n    if (await isDirectory(join(projectSourceRoot, normalizedPattern))) {\n      normalizedPattern = `${normalizedPattern}/**/*.spec.@(ts|tsx)`;\n    } else {\n      // see if matching spec file exists\n      const fileExt = extname(normalizedPattern);\n      // Replace extension to `.spec.ext`. Example: `src/app/app.component.ts`-> `src/app/app.component.spec.ts`\n      const potentialSpec = join(\n        projectSourceRoot,\n        dirname(normalizedPattern),\n        `${basename(normalizedPattern, fileExt)}.spec${fileExt}`,\n      );\n\n      if (await exists(potentialSpec)) {\n        return [potentialSpec];\n      }\n    }\n  }\n\n  return globPromise(normalizedPattern, {\n    cwd: projectSourceRoot,\n    root: projectSourceRoot,\n    nomount: true,\n    absolute: true,\n    ignore: ['**/node_modules/**', ...ignore],\n  });\n}\n\nasync function isDirectory(path: PathLike): Promise<boolean> {\n  try {\n    const stats = await fs.stat(path);\n\n    return stats.isDirectory();\n  } catch {\n    return false;\n  }\n}\n\nasync function exists(path: PathLike): Promise<boolean> {\n  try {\n    await fs.access(path, constants.F_OK);\n\n    return true;\n  } catch {\n    return false;\n  }\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/karma/index.d.ts b/artifacts/build-angular/src/builders/karma/index.d.ts new file mode 100644 index 00000000..55a57290 --- /dev/null +++ b/artifacts/build-angular/src/builders/karma/index.d.ts @@ -0,0 +1,27 @@ +/** + * @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 type { ConfigOptions } from 'karma'; +import { Observable } from 'rxjs'; +import { Configuration } from 'webpack'; +import { ExecutionTransformer } from '../../transforms'; +import { Schema as KarmaBuilderOptions } from './schema'; +export type KarmaConfigOptions = ConfigOptions & { + buildWebpack?: unknown; + configFile?: string; +}; +/** + * @experimental Direct usage of this function is considered experimental. + */ +export declare function execute(options: KarmaBuilderOptions, context: BuilderContext, transforms?: { + webpackConfiguration?: ExecutionTransformer; + karmaOptions?: (options: KarmaConfigOptions) => KarmaConfigOptions; +}): Observable; +export { KarmaBuilderOptions }; +declare const _default: import("../../../../architect/src/internal").Builder & KarmaBuilderOptions & import("@angular-devkit/core").JsonObject>; +export default _default; diff --git a/artifacts/build-angular/src/builders/karma/index.js b/artifacts/build-angular/src/builders/karma/index.js new file mode 100644 index 00000000..bdcdc3e5 --- /dev/null +++ b/artifacts/build-angular/src/builders/karma/index.js @@ -0,0 +1,217 @@ +"use strict"; +/** + * @license + * Copyright Google LLC All Rights Reserved. + * + * Use of this source code is governed by an MIT-style license that can be + * found in the LICENSE file at https://angular.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.execute = void 0; +const architect_1 = require("@angular-devkit/architect"); +const core_1 = require("@angular-devkit/core"); +const module_1 = require("module"); +const path = __importStar(require("path")); +const rxjs_1 = require("rxjs"); +const purge_cache_1 = require("../../utils/purge-cache"); +const version_1 = require("../../utils/version"); +const webpack_browser_config_1 = require("../../utils/webpack-browser-config"); +const configs_1 = require("../../webpack/configs"); +const schema_1 = require("../browser/schema"); +const find_tests_plugin_1 = require("./find-tests-plugin"); +async function initialize(options, context, webpackConfigurationTransformer) { + // Purge old build disk cache. + await (0, purge_cache_1.purgeStaleBuildCache)(context); + const { config } = await (0, webpack_browser_config_1.generateBrowserWebpackConfigFromContext)( + // only two properties are missing: + // * `outputPath` which is fixed for tests + // * `budgets` which might be incorrect due to extra dev libs + { + ...options, + outputPath: '', + budgets: undefined, + optimization: false, + buildOptimizer: false, + aot: false, + vendorChunk: true, + namedChunks: true, + extractLicenses: false, + outputHashing: schema_1.OutputHashing.None, + // The webpack tier owns the watch behavior so we want to force it in the config. + // When not in watch mode, webpack-dev-middleware will call `compiler.watch` anyway. + // https://github.com/webpack/webpack-dev-middleware/blob/698c9ae5e9bb9a013985add6189ff21c1a1ec185/src/index.js#L65 + // https://github.com/webpack/webpack/blob/cde1b73e12eb8a77eb9ba42e7920c9ec5d29c2c9/lib/Compiler.js#L379-L388 + watch: true, + }, context, (wco) => [(0, configs_1.getCommonConfig)(wco), (0, configs_1.getStylesConfig)(wco)]); + const karma = await Promise.resolve().then(() => __importStar(require('karma'))); + return [karma, (await webpackConfigurationTransformer?.(config)) ?? config]; +} +/** + * @experimental Direct usage of this function is considered experimental. + */ +function execute(options, context, transforms = {}) { + // Check Angular version. + (0, version_1.assertCompatibleAngularVersion)(context.workspaceRoot); + let singleRun; + if (options.watch !== undefined) { + singleRun = !options.watch; + } + return (0, rxjs_1.from)(initialize(options, context, transforms.webpackConfiguration)).pipe((0, rxjs_1.switchMap)(async ([karma, webpackConfig]) => { + // Determine project name from builder context target + const projectName = context.target?.project; + if (!projectName) { + throw new Error(`The 'karma' builder requires a target to be specified.`); + } + const karmaOptions = options.karmaConfig + ? {} + : getBuiltInKarmaConfig(context.workspaceRoot, projectName); + karmaOptions.singleRun = singleRun; + // Convert browsers from a string to an array + if (options.browsers) { + karmaOptions.browsers = options.browsers.split(','); + } + if (options.reporters) { + // Split along commas to make it more natural, and remove empty strings. + const reporters = options.reporters + .reduce((acc, curr) => acc.concat(curr.split(',')), []) + .filter((x) => !!x); + if (reporters.length > 0) { + karmaOptions.reporters = reporters; + } + } + if (!options.main) { + webpackConfig.entry ?? (webpackConfig.entry = {}); + if (typeof webpackConfig.entry === 'object' && !Array.isArray(webpackConfig.entry)) { + if (Array.isArray(webpackConfig.entry['main'])) { + webpackConfig.entry['main'].push(getBuiltInMainFile()); + } + else { + webpackConfig.entry['main'] = [getBuiltInMainFile()]; + } + } + } + const projectMetadata = await context.getProjectMetadata(projectName); + const sourceRoot = (projectMetadata.sourceRoot ?? projectMetadata.root ?? ''); + webpackConfig.plugins ?? (webpackConfig.plugins = []); + webpackConfig.plugins.push(new find_tests_plugin_1.FindTestsPlugin({ + include: options.include, + exclude: options.exclude, + workspaceRoot: context.workspaceRoot, + projectSourceRoot: path.join(context.workspaceRoot, sourceRoot), + })); + karmaOptions.buildWebpack = { + options, + webpackConfig, + logger: context.logger, + }; + const parsedKarmaConfig = await karma.config.parseConfig(options.karmaConfig && path.resolve(context.workspaceRoot, options.karmaConfig), transforms.karmaOptions ? transforms.karmaOptions(karmaOptions) : karmaOptions, { promiseConfig: true, throwErrors: true }); + return [karma, parsedKarmaConfig]; + }), (0, rxjs_1.switchMap)(([karma, karmaConfig]) => new rxjs_1.Observable((subscriber) => { + var _a, _b; + // Pass onto Karma to emit BuildEvents. + karmaConfig.buildWebpack ?? (karmaConfig.buildWebpack = {}); + if (typeof karmaConfig.buildWebpack === 'object') { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + (_a = karmaConfig.buildWebpack).failureCb ?? (_a.failureCb = () => subscriber.next({ success: false })); + // eslint-disable-next-line @typescript-eslint/no-explicit-any + (_b = karmaConfig.buildWebpack).successCb ?? (_b.successCb = () => subscriber.next({ success: true })); + } + // Complete the observable once the Karma server returns. + const karmaServer = new karma.Server(karmaConfig, (exitCode) => { + subscriber.next({ success: exitCode === 0 }); + subscriber.complete(); + }); + const karmaStart = karmaServer.start(); + // Cleanup, signal Karma to exit. + return () => { + void karmaStart.then(() => karmaServer.stop()); + }; + })), (0, rxjs_1.defaultIfEmpty)({ success: false })); +} +exports.execute = execute; +function getBuiltInKarmaConfig(workspaceRoot, projectName) { + let coverageFolderName = projectName.charAt(0) === '@' ? projectName.slice(1) : projectName; + if (/[A-Z]/.test(coverageFolderName)) { + coverageFolderName = core_1.strings.dasherize(coverageFolderName); + } + const workspaceRootRequire = (0, module_1.createRequire)(workspaceRoot + '/'); + // Any changes to the config here need to be synced to: packages/schematics/angular/config/files/karma.conf.js.template + return { + basePath: '', + frameworks: ['jasmine', '@angular-devkit/build-angular'], + plugins: [ + 'karma-jasmine', + 'karma-chrome-launcher', + 'karma-jasmine-html-reporter', + 'karma-coverage', + '@angular-devkit/build-angular/plugins/karma', + ].map((p) => workspaceRootRequire(p)), + client: { + clearContext: false, // leave Jasmine Spec Runner output visible in browser + }, + jasmineHtmlReporter: { + suppressAll: true, // removes the duplicated traces + }, + coverageReporter: { + dir: path.join(workspaceRoot, 'coverage', coverageFolderName), + subdir: '.', + reporters: [{ type: 'html' }, { type: 'text-summary' }], + }, + reporters: ['progress', 'kjhtml'], + browsers: ['Chrome'], + customLaunchers: { + // Chrome configured to run in a bazel sandbox. + // Disable the use of the gpu and `/dev/shm` because it causes Chrome to + // crash on some environments. + // See: + // https://github.com/puppeteer/puppeteer/blob/v1.0.0/docs/troubleshooting.md#tips + // https://stackoverflow.com/questions/50642308/webdriverexception-unknown-error-devtoolsactiveport-file-doesnt-exist-while-t + ChromeHeadlessNoSandbox: { + base: 'ChromeHeadless', + flags: ['--no-sandbox', '--headless', '--disable-gpu', '--disable-dev-shm-usage'], + }, + }, + restartOnFileChange: true, + }; +} +exports.default = (0, architect_1.createBuilder)(execute); +function getBuiltInMainFile() { + const content = Buffer.from(` + import { getTestBed } from '@angular/core/testing'; + import { + BrowserDynamicTestingModule, + platformBrowserDynamicTesting, + } from '@angular/platform-browser-dynamic/testing'; + + // Initialize the Angular testing environment. + getTestBed().initTestEnvironment(BrowserDynamicTestingModule, platformBrowserDynamicTesting(), { + errorOnUnknownElements: true, + errorOnUnknownProperties: true + }); +`).toString('base64'); + return `ng-virtual-main.js!=!data:text/javascript;base64,${content}`; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/karma/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 { BuilderContext, BuilderOutput, createBuilder } from '@angular-devkit/architect';\nimport { strings } from '@angular-devkit/core';\nimport type { Config, ConfigOptions } from 'karma';\nimport { createRequire } from 'module';\nimport * as path from 'path';\nimport { Observable, defaultIfEmpty, from, switchMap } from 'rxjs';\nimport { Configuration } from 'webpack';\nimport { ExecutionTransformer } from '../../transforms';\nimport { purgeStaleBuildCache } from '../../utils/purge-cache';\nimport { assertCompatibleAngularVersion } from '../../utils/version';\nimport { generateBrowserWebpackConfigFromContext } from '../../utils/webpack-browser-config';\nimport { getCommonConfig, getStylesConfig } from '../../webpack/configs';\nimport { Schema as BrowserBuilderOptions, OutputHashing } from '../browser/schema';\nimport { FindTestsPlugin } from './find-tests-plugin';\nimport { Schema as KarmaBuilderOptions } from './schema';\n\nexport type KarmaConfigOptions = ConfigOptions & {\n  buildWebpack?: unknown;\n  configFile?: string;\n};\n\nasync function initialize(\n  options: KarmaBuilderOptions,\n  context: BuilderContext,\n  webpackConfigurationTransformer?: ExecutionTransformer<Configuration>,\n): Promise<[typeof import('karma'), Configuration]> {\n  // Purge old build disk cache.\n  await purgeStaleBuildCache(context);\n\n  const { config } = await generateBrowserWebpackConfigFromContext(\n    // only two properties are missing:\n    // * `outputPath` which is fixed for tests\n    // * `budgets` which might be incorrect due to extra dev libs\n    {\n      ...(options as unknown as BrowserBuilderOptions),\n      outputPath: '',\n      budgets: undefined,\n      optimization: false,\n      buildOptimizer: false,\n      aot: false,\n      vendorChunk: true,\n      namedChunks: true,\n      extractLicenses: false,\n      outputHashing: OutputHashing.None,\n      // The webpack tier owns the watch behavior so we want to force it in the config.\n      // When not in watch mode, webpack-dev-middleware will call `compiler.watch` anyway.\n      // https://github.com/webpack/webpack-dev-middleware/blob/698c9ae5e9bb9a013985add6189ff21c1a1ec185/src/index.js#L65\n      // https://github.com/webpack/webpack/blob/cde1b73e12eb8a77eb9ba42e7920c9ec5d29c2c9/lib/Compiler.js#L379-L388\n      watch: true,\n    },\n    context,\n    (wco) => [getCommonConfig(wco), getStylesConfig(wco)],\n  );\n\n  const karma = await import('karma');\n\n  return [karma, (await webpackConfigurationTransformer?.(config)) ?? config];\n}\n\n/**\n * @experimental Direct usage of this function is considered experimental.\n */\nexport function execute(\n  options: KarmaBuilderOptions,\n  context: BuilderContext,\n  transforms: {\n    webpackConfiguration?: ExecutionTransformer<Configuration>;\n    // The karma options transform cannot be async without a refactor of the builder implementation\n    karmaOptions?: (options: KarmaConfigOptions) => KarmaConfigOptions;\n  } = {},\n): Observable<BuilderOutput> {\n  // Check Angular version.\n  assertCompatibleAngularVersion(context.workspaceRoot);\n\n  let singleRun: boolean | undefined;\n  if (options.watch !== undefined) {\n    singleRun = !options.watch;\n  }\n\n  return from(initialize(options, context, transforms.webpackConfiguration)).pipe(\n    switchMap(async ([karma, webpackConfig]) => {\n      // Determine project name from builder context target\n      const projectName = context.target?.project;\n      if (!projectName) {\n        throw new Error(`The 'karma' builder requires a target to be specified.`);\n      }\n\n      const karmaOptions: KarmaConfigOptions = options.karmaConfig\n        ? {}\n        : getBuiltInKarmaConfig(context.workspaceRoot, projectName);\n\n      karmaOptions.singleRun = singleRun;\n\n      // Convert browsers from a string to an array\n      if (options.browsers) {\n        karmaOptions.browsers = options.browsers.split(',');\n      }\n\n      if (options.reporters) {\n        // Split along commas to make it more natural, and remove empty strings.\n        const reporters = options.reporters\n          .reduce<string[]>((acc, curr) => acc.concat(curr.split(',')), [])\n          .filter((x) => !!x);\n\n        if (reporters.length > 0) {\n          karmaOptions.reporters = reporters;\n        }\n      }\n\n      if (!options.main) {\n        webpackConfig.entry ??= {};\n        if (typeof webpackConfig.entry === 'object' && !Array.isArray(webpackConfig.entry)) {\n          if (Array.isArray(webpackConfig.entry['main'])) {\n            webpackConfig.entry['main'].push(getBuiltInMainFile());\n          } else {\n            webpackConfig.entry['main'] = [getBuiltInMainFile()];\n          }\n        }\n      }\n\n      const projectMetadata = await context.getProjectMetadata(projectName);\n      const sourceRoot = (projectMetadata.sourceRoot ?? projectMetadata.root ?? '') as string;\n\n      webpackConfig.plugins ??= [];\n      webpackConfig.plugins.push(\n        new FindTestsPlugin({\n          include: options.include,\n          exclude: options.exclude,\n          workspaceRoot: context.workspaceRoot,\n          projectSourceRoot: path.join(context.workspaceRoot, sourceRoot),\n        }),\n      );\n\n      karmaOptions.buildWebpack = {\n        options,\n        webpackConfig,\n        logger: context.logger,\n      };\n\n      const parsedKarmaConfig = await karma.config.parseConfig(\n        options.karmaConfig && path.resolve(context.workspaceRoot, options.karmaConfig),\n        transforms.karmaOptions ? transforms.karmaOptions(karmaOptions) : karmaOptions,\n        { promiseConfig: true, throwErrors: true },\n      );\n\n      return [karma, parsedKarmaConfig] as [typeof karma, KarmaConfigOptions];\n    }),\n    switchMap(\n      ([karma, karmaConfig]) =>\n        new Observable<BuilderOutput>((subscriber) => {\n          // Pass onto Karma to emit BuildEvents.\n          karmaConfig.buildWebpack ??= {};\n          if (typeof karmaConfig.buildWebpack === 'object') {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            (karmaConfig.buildWebpack as any).failureCb ??= () =>\n              subscriber.next({ success: false });\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            (karmaConfig.buildWebpack as any).successCb ??= () =>\n              subscriber.next({ success: true });\n          }\n\n          // Complete the observable once the Karma server returns.\n          const karmaServer = new karma.Server(karmaConfig as Config, (exitCode) => {\n            subscriber.next({ success: exitCode === 0 });\n            subscriber.complete();\n          });\n\n          const karmaStart = karmaServer.start();\n\n          // Cleanup, signal Karma to exit.\n          return () => {\n            void karmaStart.then(() => karmaServer.stop());\n          };\n        }),\n    ),\n    defaultIfEmpty({ success: false }),\n  );\n}\n\nfunction getBuiltInKarmaConfig(\n  workspaceRoot: string,\n  projectName: string,\n): ConfigOptions & Record<string, unknown> {\n  let coverageFolderName = projectName.charAt(0) === '@' ? projectName.slice(1) : projectName;\n  if (/[A-Z]/.test(coverageFolderName)) {\n    coverageFolderName = strings.dasherize(coverageFolderName);\n  }\n\n  const workspaceRootRequire = createRequire(workspaceRoot + '/');\n\n  // Any changes to the config here need to be synced to: packages/schematics/angular/config/files/karma.conf.js.template\n  return {\n    basePath: '',\n    frameworks: ['jasmine', '@angular-devkit/build-angular'],\n    plugins: [\n      'karma-jasmine',\n      'karma-chrome-launcher',\n      'karma-jasmine-html-reporter',\n      'karma-coverage',\n      '@angular-devkit/build-angular/plugins/karma',\n    ].map((p) => workspaceRootRequire(p)),\n    client: {\n      clearContext: false, // leave Jasmine Spec Runner output visible in browser\n    },\n    jasmineHtmlReporter: {\n      suppressAll: true, // removes the duplicated traces\n    },\n    coverageReporter: {\n      dir: path.join(workspaceRoot, 'coverage', coverageFolderName),\n      subdir: '.',\n      reporters: [{ type: 'html' }, { type: 'text-summary' }],\n    },\n    reporters: ['progress', 'kjhtml'],\n    browsers: ['Chrome'],\n    customLaunchers: {\n      // Chrome configured to run in a bazel sandbox.\n      // Disable the use of the gpu and `/dev/shm` because it causes Chrome to\n      // crash on some environments.\n      // See:\n      //   https://github.com/puppeteer/puppeteer/blob/v1.0.0/docs/troubleshooting.md#tips\n      //   https://stackoverflow.com/questions/50642308/webdriverexception-unknown-error-devtoolsactiveport-file-doesnt-exist-while-t\n      ChromeHeadlessNoSandbox: {\n        base: 'ChromeHeadless',\n        flags: ['--no-sandbox', '--headless', '--disable-gpu', '--disable-dev-shm-usage'],\n      },\n    },\n    restartOnFileChange: true,\n  };\n}\n\nexport { KarmaBuilderOptions };\nexport default createBuilder<Record<string, string> & KarmaBuilderOptions>(execute);\n\nfunction getBuiltInMainFile(): string {\n  const content = Buffer.from(\n    `\n  import { getTestBed } from '@angular/core/testing';\n  import {\n    BrowserDynamicTestingModule,\n    platformBrowserDynamicTesting,\n   } from '@angular/platform-browser-dynamic/testing';\n\n  // Initialize the Angular testing environment.\n  getTestBed().initTestEnvironment(BrowserDynamicTestingModule, platformBrowserDynamicTesting(), {\n    errorOnUnknownElements: true,\n    errorOnUnknownProperties: true\n  });\n`,\n  ).toString('base64');\n\n  return `ng-virtual-main.js!=!data:text/javascript;base64,${content}`;\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/karma/schema.d.ts b/artifacts/build-angular/src/builders/karma/schema.d.ts new file mode 100644 index 00000000..281f4afd --- /dev/null +++ b/artifacts/build-angular/src/builders/karma/schema.d.ts @@ -0,0 +1,196 @@ +/** + * Karma target options for Build Facade. + */ +export interface Schema { + /** + * List of static application assets. + */ + assets?: AssetPattern[]; + /** + * Override which browsers tests are run against. + */ + browsers?: string; + /** + * Output a code coverage report. + */ + codeCoverage?: boolean; + /** + * Globs to exclude from code coverage. + */ + codeCoverageExclude?: string[]; + /** + * Globs of files to exclude, relative to the project root. + */ + exclude?: string[]; + /** + * Replace compilation source files with other compilation source files in the build. + */ + fileReplacements?: FileReplacement[]; + /** + * Globs of files to include, relative to project root. + * There are 2 special cases: + * - when a path to directory is provided, all spec files ending ".spec.@(ts|tsx)" will be + * included + * - when a path to a file is provided, and a matching spec file exists it will be included + * instead. + */ + include?: string[]; + /** + * The stylesheet language to use for the application's inline component styles. + */ + inlineStyleLanguage?: InlineStyleLanguage; + /** + * The name of the Karma configuration file. + */ + karmaConfig?: string; + /** + * The name of the main entry-point file. + */ + main?: string; + /** + * Enable and define the file watching poll time period in milliseconds. + */ + poll?: number; + /** + * Polyfills to be included in the build. + */ + polyfills?: Polyfills; + /** + * Do not use the real path when resolving modules. If unset then will default to `true` if + * NodeJS option --preserve-symlinks is set. + */ + preserveSymlinks?: boolean; + /** + * Log progress to the console while building. + */ + progress?: boolean; + /** + * Karma reporters to use. Directly passed to the karma runner. + */ + reporters?: string[]; + /** + * Global scripts to be included in the build. + */ + scripts?: ScriptElement[]; + /** + * Output source maps for scripts and styles. For more information, see + * https://angular.io/guide/workspace-config#source-map-configuration. + */ + sourceMap?: SourceMapUnion; + /** + * Options to pass to style preprocessors + */ + stylePreprocessorOptions?: StylePreprocessorOptions; + /** + * Global styles to be included in the build. + */ + styles?: StyleElement[]; + /** + * The name of the TypeScript configuration file. + */ + tsConfig: string; + /** + * Run build when files change. + */ + watch?: boolean; + /** + * TypeScript configuration for Web Worker modules. + */ + webWorkerTsConfig?: string; +} +export type AssetPattern = AssetPatternClass | string; +export interface AssetPatternClass { + /** + * 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; + src?: string; + with?: string; +} +/** + * The stylesheet language to use for the application's inline component styles. + */ +export declare enum InlineStyleLanguage { + Css = "css", + Less = "less", + Sass = "sass", + Scss = "scss" +} +/** + * Polyfills to be included in the build. + */ +export type Polyfills = string[] | string; +export type ScriptElement = ScriptClass | string; +export interface ScriptClass { + /** + * The bundle name for this extra entry point. + */ + bundleName?: string; + /** + * If the bundle will be referenced in the HTML file. + */ + inject?: boolean; + /** + * The file to include. + */ + input: string; +} +/** + * Output source maps for scripts and styles. For more information, see + * https://angular.io/guide/workspace-config#source-map-configuration. + */ +export type SourceMapUnion = boolean | SourceMapClass; +export interface SourceMapClass { + /** + * Output source maps for all scripts. + */ + scripts?: boolean; + /** + * Output source maps for all styles. + */ + styles?: boolean; + /** + * Resolve vendor packages source maps. + */ + vendor?: boolean; +} +/** + * Options to pass to style preprocessors + */ +export interface StylePreprocessorOptions { + /** + * Paths to include. Paths will be resolved to workspace root. + */ + includePaths?: string[]; +} +export type StyleElement = StyleClass | string; +export interface StyleClass { + /** + * The bundle name for this extra entry point. + */ + bundleName?: string; + /** + * If the bundle will be referenced in the HTML file. + */ + inject?: boolean; + /** + * The file to include. + */ + input: string; +} diff --git a/artifacts/build-angular/src/builders/karma/schema.js b/artifacts/build-angular/src/builders/karma/schema.js new file mode 100644 index 00000000..f6d3759f --- /dev/null +++ b/artifacts/build-angular/src/builders/karma/schema.js @@ -0,0 +1,16 @@ +"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 }); +exports.InlineStyleLanguage = void 0; +/** + * The stylesheet language to use for the application's inline component styles. + */ +var InlineStyleLanguage; +(function (InlineStyleLanguage) { + InlineStyleLanguage["Css"] = "css"; + InlineStyleLanguage["Less"] = "less"; + InlineStyleLanguage["Sass"] = "sass"; + InlineStyleLanguage["Scss"] = "scss"; +})(InlineStyleLanguage = exports.InlineStyleLanguage || (exports.InlineStyleLanguage = {})); +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/karma/schema.json b/artifacts/build-angular/src/builders/karma/schema.json new file mode 100644 index 00000000..7f9a5e69 --- /dev/null +++ b/artifacts/build-angular/src/builders/karma/schema.json @@ -0,0 +1,302 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema", + "title": "Karma Target", + "description": "Karma target options for Build Facade.", + "type": "object", + "properties": { + "main": { + "type": "string", + "description": "The name of the main entry-point file." + }, + "tsConfig": { + "type": "string", + "description": "The name of the TypeScript configuration file." + }, + "karmaConfig": { + "type": "string", + "description": "The name of the Karma configuration file." + }, + "polyfills": { + "description": "Polyfills to be included in the build.", + "oneOf": [ + { + "type": "array", + "description": "A list of polyfills to include in the build. Can be a full path for a file, relative to the current workspace or module specifier. Example: 'zone.js'.", + "items": { + "type": "string", + "uniqueItems": true + }, + "default": [] + }, + { + "type": "string", + "description": "The full path for the polyfills file, relative to the current workspace or a module specifier. Example: 'zone.js'." + } + ] + }, + "assets": { + "type": "array", + "description": "List of static application assets.", + "default": [], + "items": { + "$ref": "#/definitions/assetPattern" + } + }, + "scripts": { + "description": "Global scripts to be included in the build.", + "type": "array", + "default": [], + "items": { + "oneOf": [ + { + "type": "object", + "properties": { + "input": { + "type": "string", + "description": "The file to include.", + "pattern": "\\.[cm]?jsx?$" + }, + "bundleName": { + "type": "string", + "pattern": "^[\\w\\-.]*$", + "description": "The bundle name for this extra entry point." + }, + "inject": { + "type": "boolean", + "description": "If the bundle will be referenced in the HTML file.", + "default": true + } + }, + "additionalProperties": false, + "required": ["input"] + }, + { + "type": "string", + "description": "The file to include.", + "pattern": "\\.[cm]?jsx?$" + } + ] + } + }, + "styles": { + "description": "Global styles to be included in the build.", + "type": "array", + "default": [], + "items": { + "oneOf": [ + { + "type": "object", + "properties": { + "input": { + "type": "string", + "description": "The file to include.", + "pattern": "\\.(?:css|scss|sass|less)$" + }, + "bundleName": { + "type": "string", + "pattern": "^[\\w\\-.]*$", + "description": "The bundle name for this extra entry point." + }, + "inject": { + "type": "boolean", + "description": "If the bundle will be referenced in the HTML file.", + "default": true + } + }, + "additionalProperties": false, + "required": ["input"] + }, + { + "type": "string", + "description": "The file to include.", + "pattern": "\\.(?:css|scss|sass|less)$" + } + ] + } + }, + "inlineStyleLanguage": { + "description": "The stylesheet language to use for the application's inline component styles.", + "type": "string", + "default": "css", + "enum": ["css", "less", "sass", "scss"] + }, + "stylePreprocessorOptions": { + "description": "Options to pass to style preprocessors", + "type": "object", + "properties": { + "includePaths": { + "description": "Paths to include. Paths will be resolved to workspace root.", + "type": "array", + "items": { + "type": "string" + }, + "default": [] + } + }, + "additionalProperties": false + }, + "include": { + "type": "array", + "items": { + "type": "string" + }, + "default": ["**/*.spec.ts"], + "description": "Globs of files to include, relative to project root. \nThere are 2 special cases:\n - when a path to directory is provided, all spec files ending \".spec.@(ts|tsx)\" will be included\n - when a path to a file is provided, and a matching spec file exists it will be included instead." + }, + "exclude": { + "type": "array", + "items": { + "type": "string" + }, + "default": [], + "description": "Globs of files to exclude, relative to the project root." + }, + "sourceMap": { + "description": "Output source maps for scripts and styles. For more information, see https://angular.io/guide/workspace-config#source-map-configuration.", + "default": true, + "oneOf": [ + { + "type": "object", + "properties": { + "scripts": { + "type": "boolean", + "description": "Output source maps for all scripts.", + "default": true + }, + "styles": { + "type": "boolean", + "description": "Output source maps for all styles.", + "default": true + }, + "vendor": { + "type": "boolean", + "description": "Resolve vendor packages source maps.", + "default": false + } + }, + "additionalProperties": false + }, + { + "type": "boolean" + } + ] + }, + "progress": { + "type": "boolean", + "description": "Log progress to the console while building.", + "default": true + }, + "watch": { + "type": "boolean", + "description": "Run build when files change." + }, + "poll": { + "type": "number", + "description": "Enable and define the file watching poll time period in milliseconds." + }, + "preserveSymlinks": { + "type": "boolean", + "description": "Do not use the real path when resolving modules. If unset then will default to `true` if NodeJS option --preserve-symlinks is set." + }, + "browsers": { + "type": "string", + "description": "Override which browsers tests are run against." + }, + "codeCoverage": { + "type": "boolean", + "description": "Output a code coverage report.", + "default": false + }, + "codeCoverageExclude": { + "type": "array", + "description": "Globs to exclude from code coverage.", + "items": { + "type": "string" + }, + "default": [] + }, + "fileReplacements": { + "description": "Replace compilation source files with other compilation source files in the build.", + "type": "array", + "items": { + "oneOf": [ + { + "type": "object", + "properties": { + "src": { + "type": "string" + }, + "replaceWith": { + "type": "string" + } + }, + "additionalProperties": false, + "required": ["src", "replaceWith"] + }, + { + "type": "object", + "properties": { + "replace": { + "type": "string" + }, + "with": { + "type": "string" + } + }, + "additionalProperties": false, + "required": ["replace", "with"] + } + ] + }, + "default": [] + }, + "reporters": { + "type": "array", + "description": "Karma reporters to use. Directly passed to the karma runner.", + "items": { + "type": "string" + } + }, + "webWorkerTsConfig": { + "type": "string", + "description": "TypeScript configuration for Web Worker modules." + } + }, + "additionalProperties": false, + "required": ["tsConfig"], + "definitions": { + "assetPattern": { + "oneOf": [ + { + "type": "object", + "properties": { + "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." + }, + "output": { + "type": "string", + "description": "Absolute path within the output." + }, + "ignore": { + "description": "An array of globs to ignore.", + "type": "array", + "items": { + "type": "string" + } + } + }, + "additionalProperties": false, + "required": ["glob", "input", "output"] + }, + { + "type": "string" + } + ] + } + } +} diff --git a/artifacts/build-angular/src/builders/ng-packagr/index.d.ts b/artifacts/build-angular/src/builders/ng-packagr/index.d.ts new file mode 100644 index 00000000..dce09bea --- /dev/null +++ b/artifacts/build-angular/src/builders/ng-packagr/index.d.ts @@ -0,0 +1,17 @@ +/** + * @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 { Observable } from 'rxjs'; +import { Schema as NgPackagrBuilderOptions } from './schema'; +/** + * @experimental Direct usage of this function is considered experimental. + */ +export declare function execute(options: NgPackagrBuilderOptions, context: BuilderContext): Observable; +export { NgPackagrBuilderOptions }; +declare const _default: import("../../../../architect/src/internal").Builder & NgPackagrBuilderOptions & import("../../../../core/src").JsonObject>; +export default _default; diff --git a/artifacts/build-angular/src/builders/ng-packagr/index.js b/artifacts/build-angular/src/builders/ng-packagr/index.js new file mode 100644 index 00000000..ec9d267b --- /dev/null +++ b/artifacts/build-angular/src/builders/ng-packagr/index.js @@ -0,0 +1,67 @@ +"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.execute = void 0; +const architect_1 = require("@angular-devkit/architect"); +const path_1 = require("path"); +const rxjs_1 = require("rxjs"); +const normalize_cache_1 = require("../../utils/normalize-cache"); +const purge_cache_1 = require("../../utils/purge-cache"); +/** + * @experimental Direct usage of this function is considered experimental. + */ +function execute(options, context) { + return (0, rxjs_1.from)((async () => { + // Purge old build disk cache. + await (0, purge_cache_1.purgeStaleBuildCache)(context); + const root = context.workspaceRoot; + const packager = (await Promise.resolve().then(() => __importStar(require('ng-packagr')))).ngPackagr(); + packager.forProject((0, path_1.resolve)(root, options.project)); + if (options.tsConfig) { + packager.withTsConfig((0, path_1.resolve)(root, options.tsConfig)); + } + const projectName = context.target?.project; + if (!projectName) { + throw new Error('The builder requires a target.'); + } + const metadata = await context.getProjectMetadata(projectName); + const { enabled: cacheEnabled, path: cacheDirectory } = (0, normalize_cache_1.normalizeCacheOptions)(metadata, context.workspaceRoot); + const ngPackagrOptions = { + cacheEnabled, + cacheDirectory: (0, path_1.join)(cacheDirectory, 'ng-packagr'), + }; + return { packager, ngPackagrOptions }; + })()).pipe((0, rxjs_1.switchMap)(({ packager, ngPackagrOptions }) => options.watch ? packager.watch(ngPackagrOptions) : packager.build(ngPackagrOptions)), (0, rxjs_1.mapTo)({ success: true }), (0, rxjs_1.catchError)((err) => (0, rxjs_1.of)({ success: false, error: err.message }))); +} +exports.execute = execute; +exports.default = (0, architect_1.createBuilder)(execute); +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/ng-packagr/schema.d.ts b/artifacts/build-angular/src/builders/ng-packagr/schema.d.ts new file mode 100644 index 00000000..6dd1649a --- /dev/null +++ b/artifacts/build-angular/src/builders/ng-packagr/schema.d.ts @@ -0,0 +1,17 @@ +/** + * ng-packagr target options for Build Architect. Use to build library projects. + */ +export interface Schema { + /** + * The file path for the ng-packagr configuration file, relative to the current workspace. + */ + project: string; + /** + * The full path for the TypeScript configuration file, relative to the current workspace. + */ + tsConfig?: string; + /** + * Run build when files change. + */ + watch?: boolean; +} diff --git a/artifacts/build-angular/src/builders/ng-packagr/schema.js b/artifacts/build-angular/src/builders/ng-packagr/schema.js new file mode 100644 index 00000000..fa43c587 --- /dev/null +++ b/artifacts/build-angular/src/builders/ng-packagr/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvYW5ndWxhcl9kZXZraXQvYnVpbGRfYW5ndWxhci9zcmMvYnVpbGRlcnMvbmctcGFja2Fnci9zY2hlbWEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUNBLG1GQUFtRjtBQUNuRixvRkFBb0YiLCJzb3VyY2VzQ29udGVudCI6WyJcbi8vIFRISVMgRklMRSBJUyBBVVRPTUFUSUNBTExZIEdFTkVSQVRFRC4gVE8gVVBEQVRFIFRISVMgRklMRSBZT1UgTkVFRCBUTyBDSEFOR0UgVEhFXG4vLyBDT1JSRVNQT05ESU5HIEpTT04gU0NIRU1BIEZJTEUsIFRIRU4gUlVOIGRldmtpdC1hZG1pbiBidWlsZCAob3IgYmF6ZWwgYnVpbGQgLi4uKS5cblxuLyoqXG4gKiBuZy1wYWNrYWdyIHRhcmdldCBvcHRpb25zIGZvciBCdWlsZCBBcmNoaXRlY3QuIFVzZSB0byBidWlsZCBsaWJyYXJ5IHByb2plY3RzLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFNjaGVtYSB7XG4gICAgLyoqXG4gICAgICogVGhlIGZpbGUgcGF0aCBmb3IgdGhlIG5nLXBhY2thZ3IgY29uZmlndXJhdGlvbiBmaWxlLCByZWxhdGl2ZSB0byB0aGUgY3VycmVudCB3b3Jrc3BhY2UuXG4gICAgICovXG4gICAgcHJvamVjdDogc3RyaW5nO1xuICAgIC8qKlxuICAgICAqIFRoZSBmdWxsIHBhdGggZm9yIHRoZSBUeXBlU2NyaXB0IGNvbmZpZ3VyYXRpb24gZmlsZSwgcmVsYXRpdmUgdG8gdGhlIGN1cnJlbnQgd29ya3NwYWNlLlxuICAgICAqL1xuICAgIHRzQ29uZmlnPzogc3RyaW5nO1xuICAgIC8qKlxuICAgICAqIFJ1biBidWlsZCB3aGVuIGZpbGVzIGNoYW5nZS5cbiAgICAgKi9cbiAgICB3YXRjaD86IGJvb2xlYW47XG59XG4iXX0= \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/ng-packagr/schema.json b/artifacts/build-angular/src/builders/ng-packagr/schema.json new file mode 100644 index 00000000..9fd60637 --- /dev/null +++ b/artifacts/build-angular/src/builders/ng-packagr/schema.json @@ -0,0 +1,23 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema", + "title": "ng-packagr Target", + "description": "ng-packagr target options for Build Architect. Use to build library projects.", + "type": "object", + "properties": { + "project": { + "type": "string", + "description": "The file path for the ng-packagr configuration file, relative to the current workspace." + }, + "tsConfig": { + "type": "string", + "description": "The full path for the TypeScript configuration file, relative to the current workspace." + }, + "watch": { + "type": "boolean", + "description": "Run build when files change.", + "default": false + } + }, + "additionalProperties": false, + "required": ["project"] +} diff --git a/artifacts/build-angular/src/builders/protractor/index.d.ts b/artifacts/build-angular/src/builders/protractor/index.d.ts new file mode 100644 index 00000000..beac7ea2 --- /dev/null +++ b/artifacts/build-angular/src/builders/protractor/index.d.ts @@ -0,0 +1,17 @@ +/** + * @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 } from '@angular-devkit/core'; +import { Schema as ProtractorBuilderOptions } from './schema'; +export { ProtractorBuilderOptions }; +/** + * @experimental Direct usage of this function is considered experimental. + */ +export declare function execute(options: ProtractorBuilderOptions, context: BuilderContext): Promise; +declare const _default: import("../../../../architect/src/internal").Builder; +export default _default; diff --git a/artifacts/build-angular/src/builders/protractor/index.js b/artifacts/build-angular/src/builders/protractor/index.js new file mode 100644 index 00000000..8d2e12dc --- /dev/null +++ b/artifacts/build-angular/src/builders/protractor/index.js @@ -0,0 +1,168 @@ +"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.execute = void 0; +const architect_1 = require("@angular-devkit/architect"); +const core_1 = require("@angular-devkit/core"); +const path_1 = require("path"); +const url = __importStar(require("url")); +const utils_1 = require("../../utils"); +const error_1 = require("../../utils/error"); +function runProtractor(root, options) { + const additionalProtractorConfig = { + baseUrl: options.baseUrl, + specs: options.specs && options.specs.length ? options.specs : undefined, + suite: options.suite, + jasmineNodeOpts: { + grep: options.grep, + invertGrep: options.invertGrep, + }, + }; + // TODO: Protractor manages process.exit itself, so this target will allways quit the + // process. To work around this we run it in a subprocess. + // https://github.com/angular/protractor/issues/4160 + return (0, utils_1.runModuleAsObservableFork)(root, 'protractor/built/launcher', 'init', [ + (0, path_1.resolve)(root, options.protractorConfig), + additionalProtractorConfig, + ]).toPromise(); +} +async function updateWebdriver() { + // The webdriver-manager update command can only be accessed via a deep import. + const webdriverDeepImport = 'webdriver-manager/built/lib/cmds/update'; + let path; + try { + const protractorPath = require.resolve('protractor'); + path = require.resolve(webdriverDeepImport, { paths: [protractorPath] }); + } + catch (error) { + (0, error_1.assertIsError)(error); + if (error.code !== 'MODULE_NOT_FOUND') { + throw error; + } + } + if (!path) { + throw new Error(core_1.tags.stripIndents ` + Cannot automatically find webdriver-manager to update. + Update webdriver-manager manually and run 'ng e2e --no-webdriver-update' instead. + `); + } + const webdriverUpdate = await Promise.resolve(`${path}`).then(s => __importStar(require(s))); + // const webdriverUpdate = await import(path) as typeof import ('webdriver-manager/built/lib/cmds/update'); + // run `webdriver-manager update --standalone false --gecko false --quiet` + // if you change this, update the command comment in prev line + return webdriverUpdate.program.run({ + standalone: false, + gecko: false, + quiet: true, + }); +} +/** + * @experimental Direct usage of this function is considered experimental. + */ +async function execute(options, context) { + context.logger.warn('Protractor has been deprecated including its support in the Angular CLI. For additional information and alternatives, please see https://github.com/angular/protractor/issues/5502.'); + // ensure that only one of these options is used + if (options.devServerTarget && options.baseUrl) { + throw new Error(core_1.tags.stripIndents ` + The 'baseUrl' option cannot be used with 'devServerTarget'. + When present, 'devServerTarget' will be used to automatically setup 'baseUrl' for Protractor. + `); + } + if (options.webdriverUpdate) { + await updateWebdriver(); + } + let baseUrl = options.baseUrl; + let server; + try { + if (options.devServerTarget) { + const target = (0, architect_1.targetFromTargetString)(options.devServerTarget); + const serverOptions = await context.getTargetOptions(target); + const overrides = { + watch: false, + liveReload: false, + }; + if (options.host !== undefined) { + overrides.host = options.host; + } + else if (typeof serverOptions.host === 'string') { + options.host = serverOptions.host; + } + else { + options.host = overrides.host = 'localhost'; + } + if (options.port !== undefined) { + overrides.port = options.port; + } + else if (typeof serverOptions.port === 'number') { + options.port = serverOptions.port; + } + server = await context.scheduleTarget(target, overrides); + const result = await server.result; + if (!result.success) { + return { success: false }; + } + if (typeof serverOptions.publicHost === 'string') { + let publicHost = serverOptions.publicHost; + if (!/^\w+:\/\//.test(publicHost)) { + publicHost = `${serverOptions.ssl ? 'https' : 'http'}://${publicHost}`; + } + const clientUrl = url.parse(publicHost); + baseUrl = url.format(clientUrl); + } + else if (typeof result.baseUrl === 'string') { + baseUrl = result.baseUrl; + } + else if (typeof result.port === 'number') { + baseUrl = url.format({ + protocol: serverOptions.ssl ? 'https' : 'http', + hostname: options.host, + port: result.port.toString(), + }); + } + } + // Like the baseUrl in protractor config file when using the API we need to add + // a trailing slash when provide to the baseUrl. + if (baseUrl && !baseUrl.endsWith('/')) { + baseUrl += '/'; + } + return await runProtractor(context.workspaceRoot, { ...options, baseUrl }); + } + catch { + return { success: false }; + } + finally { + await server?.stop(); + } +} +exports.execute = execute; +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/protractor/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, tags } from '@angular-devkit/core';\nimport { resolve } from 'path';\nimport * as url from 'url';\nimport { runModuleAsObservableFork } from '../../utils';\nimport { assertIsError } from '../../utils/error';\nimport { DevServerBuilderOptions } from '../dev-server/index';\nimport { Schema as ProtractorBuilderOptions } from './schema';\n\ninterface JasmineNodeOpts {\n  jasmineNodeOpts: {\n    grep?: string;\n    invertGrep?: boolean;\n  };\n}\n\nfunction runProtractor(root: string, options: ProtractorBuilderOptions): Promise<BuilderOutput> {\n  const additionalProtractorConfig: Partial<ProtractorBuilderOptions> & Partial<JasmineNodeOpts> = {\n    baseUrl: options.baseUrl,\n    specs: options.specs && options.specs.length ? options.specs : undefined,\n    suite: options.suite,\n    jasmineNodeOpts: {\n      grep: options.grep,\n      invertGrep: options.invertGrep,\n    },\n  };\n\n  // TODO: Protractor manages process.exit itself, so this target will allways quit the\n  // process. To work around this we run it in a subprocess.\n  // https://github.com/angular/protractor/issues/4160\n  return runModuleAsObservableFork(root, 'protractor/built/launcher', 'init', [\n    resolve(root, options.protractorConfig),\n    additionalProtractorConfig,\n  ]).toPromise() as Promise<BuilderOutput>;\n}\n\nasync function updateWebdriver() {\n  // The webdriver-manager update command can only be accessed via a deep import.\n  const webdriverDeepImport = 'webdriver-manager/built/lib/cmds/update';\n\n  let path;\n  try {\n    const protractorPath = require.resolve('protractor');\n\n    path = require.resolve(webdriverDeepImport, { paths: [protractorPath] });\n  } catch (error) {\n    assertIsError(error);\n    if (error.code !== 'MODULE_NOT_FOUND') {\n      throw error;\n    }\n  }\n\n  if (!path) {\n    throw new Error(tags.stripIndents`\n      Cannot automatically find webdriver-manager to update.\n      Update webdriver-manager manually and run 'ng e2e --no-webdriver-update' instead.\n    `);\n  }\n\n  const webdriverUpdate = await import(path);\n  // const webdriverUpdate = await import(path) as typeof import ('webdriver-manager/built/lib/cmds/update');\n\n  // run `webdriver-manager update --standalone false --gecko false --quiet`\n  // if you change this, update the command comment in prev line\n  return webdriverUpdate.program.run({\n    standalone: false,\n    gecko: false,\n    quiet: true,\n  } as unknown as JSON);\n}\n\nexport { ProtractorBuilderOptions };\n\n/**\n * @experimental Direct usage of this function is considered experimental.\n */\nexport async function execute(\n  options: ProtractorBuilderOptions,\n  context: BuilderContext,\n): Promise<BuilderOutput> {\n  context.logger.warn(\n    'Protractor has been deprecated including its support in the Angular CLI. For additional information and alternatives, please see https://github.com/angular/protractor/issues/5502.',\n  );\n\n  // ensure that only one of these options is used\n  if (options.devServerTarget && options.baseUrl) {\n    throw new Error(tags.stripIndents`\n    The 'baseUrl' option cannot be used with 'devServerTarget'.\n    When present, 'devServerTarget' will be used to automatically setup 'baseUrl' for Protractor.\n    `);\n  }\n\n  if (options.webdriverUpdate) {\n    await updateWebdriver();\n  }\n\n  let baseUrl = options.baseUrl;\n  let server;\n\n  try {\n    if (options.devServerTarget) {\n      const target = targetFromTargetString(options.devServerTarget);\n      const serverOptions = await context.getTargetOptions(target);\n\n      const overrides = {\n        watch: false,\n        liveReload: false,\n      } as DevServerBuilderOptions & json.JsonObject;\n\n      if (options.host !== undefined) {\n        overrides.host = options.host;\n      } else if (typeof serverOptions.host === 'string') {\n        options.host = serverOptions.host;\n      } else {\n        options.host = overrides.host = 'localhost';\n      }\n\n      if (options.port !== undefined) {\n        overrides.port = options.port;\n      } else if (typeof serverOptions.port === 'number') {\n        options.port = serverOptions.port;\n      }\n\n      server = await context.scheduleTarget(target, overrides);\n      const result = await server.result;\n      if (!result.success) {\n        return { success: false };\n      }\n\n      if (typeof serverOptions.publicHost === 'string') {\n        let publicHost = serverOptions.publicHost;\n        if (!/^\\w+:\\/\\//.test(publicHost)) {\n          publicHost = `${serverOptions.ssl ? 'https' : 'http'}://${publicHost}`;\n        }\n        const clientUrl = url.parse(publicHost);\n        baseUrl = url.format(clientUrl);\n      } else if (typeof result.baseUrl === 'string') {\n        baseUrl = result.baseUrl;\n      } else if (typeof result.port === 'number') {\n        baseUrl = url.format({\n          protocol: serverOptions.ssl ? 'https' : 'http',\n          hostname: options.host,\n          port: result.port.toString(),\n        });\n      }\n    }\n\n    // Like the baseUrl in protractor config file when using the API we need to add\n    // a trailing slash when provide to the baseUrl.\n    if (baseUrl && !baseUrl.endsWith('/')) {\n      baseUrl += '/';\n    }\n\n    return await runProtractor(context.workspaceRoot, { ...options, baseUrl });\n  } catch {\n    return { success: false };\n  } finally {\n    await server?.stop();\n  }\n}\n\nexport default createBuilder<ProtractorBuilderOptions>(execute);\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/protractor/schema.d.ts b/artifacts/build-angular/src/builders/protractor/schema.d.ts new file mode 100644 index 00000000..a81aeb6c --- /dev/null +++ b/artifacts/build-angular/src/builders/protractor/schema.d.ts @@ -0,0 +1,47 @@ +/** + * Protractor target options for Build Facade. + */ +export interface Schema { + /** + * Base URL for protractor to connect to. + */ + baseUrl?: string; + /** + * A dev-server builder target to run tests against in the format of + * `project:target[:configuration]`. You can also pass in more than one configuration name + * as a comma-separated list. Example: `project:target:production,staging`. + */ + devServerTarget?: string; + /** + * Execute specs whose names match the pattern, which is internally compiled to a RegExp. + */ + grep?: string; + /** + * Host to listen on. + */ + host?: string; + /** + * Invert the selection specified by the 'grep' option. + */ + invertGrep?: boolean; + /** + * The port to use to serve the application. + */ + port?: number; + /** + * The name of the Protractor configuration file. + */ + protractorConfig: string; + /** + * Override specs in the protractor config. + */ + specs?: string[]; + /** + * Override suite in the protractor config. + */ + suite?: string; + /** + * Try to update webdriver. + */ + webdriverUpdate?: boolean; +} diff --git a/artifacts/build-angular/src/builders/protractor/schema.js b/artifacts/build-angular/src/builders/protractor/schema.js new file mode 100644 index 00000000..12533312 --- /dev/null +++ b/artifacts/build-angular/src/builders/protractor/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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 \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/protractor/schema.json b/artifacts/build-angular/src/builders/protractor/schema.json new file mode 100644 index 00000000..286a315a --- /dev/null +++ b/artifacts/build-angular/src/builders/protractor/schema.json @@ -0,0 +1,58 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema", + "title": "Protractor Target", + "description": "Protractor target options for Build Facade.", + "type": "object", + "properties": { + "protractorConfig": { + "type": "string", + "description": "The name of the Protractor configuration file." + }, + "devServerTarget": { + "type": "string", + "description": "A dev-server builder target to run tests against in the format of `project:target[:configuration]`. You can also pass in more than one configuration name as a comma-separated list. Example: `project:target:production,staging`.", + "pattern": "^([^:\\s]+:[^:\\s]+(:[^\\s]+)?)?$" + }, + "grep": { + "type": "string", + "description": "Execute specs whose names match the pattern, which is internally compiled to a RegExp." + }, + "invertGrep": { + "type": "boolean", + "description": "Invert the selection specified by the 'grep' option.", + "default": false + }, + "specs": { + "type": "array", + "description": "Override specs in the protractor config.", + "default": [], + "items": { + "type": "string", + "description": "Spec name." + } + }, + "suite": { + "type": "string", + "description": "Override suite in the protractor config." + }, + "webdriverUpdate": { + "type": "boolean", + "description": "Try to update webdriver.", + "default": true + }, + "port": { + "type": "number", + "description": "The port to use to serve the application." + }, + "host": { + "type": "string", + "description": "Host to listen on." + }, + "baseUrl": { + "type": "string", + "description": "Base URL for protractor to connect to." + } + }, + "additionalProperties": false, + "required": ["protractorConfig"] +} diff --git a/artifacts/build-angular/src/builders/server/index.d.ts b/artifacts/build-angular/src/builders/server/index.d.ts new file mode 100644 index 00000000..e1c45d0b --- /dev/null +++ b/artifacts/build-angular/src/builders/server/index.d.ts @@ -0,0 +1,32 @@ +/** + * @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 { Observable } from 'rxjs'; +import webpack from 'webpack'; +import { ExecutionTransformer } from '../../transforms'; +import { Schema as ServerBuilderOptions } from './schema'; +/** + * @experimental Direct usage of this type is considered experimental. + */ +export type ServerBuilderOutput = BuilderOutput & { + baseOutputPath: string; + outputPath: string; + outputs: { + locale?: string; + path: string; + }[]; +}; +export { ServerBuilderOptions }; +/** + * @experimental Direct usage of this function is considered experimental. + */ +export declare function execute(options: ServerBuilderOptions, context: BuilderContext, transforms?: { + webpackConfiguration?: ExecutionTransformer; +}): Observable; +declare const _default: import("../../../../architect/src/internal").Builder; +export default _default; diff --git a/artifacts/build-angular/src/builders/server/index.js b/artifacts/build-angular/src/builders/server/index.js new file mode 100644 index 00000000..dac124cf --- /dev/null +++ b/artifacts/build-angular/src/builders/server/index.js @@ -0,0 +1,201 @@ +"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.execute = void 0; +const architect_1 = require("@angular-devkit/architect"); +const build_webpack_1 = require("@angular-devkit/build-webpack"); +const promises_1 = require("node:fs/promises"); +const path = __importStar(require("node:path")); +const rxjs_1 = require("rxjs"); +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"); +const helpers_1 = require("../../webpack/utils/helpers"); +const stats_1 = require("../../webpack/utils/stats"); +/** + * @experimental Direct usage of this function is considered experimental. + */ +function execute(options, context, transforms = {}) { + const root = context.workspaceRoot; + // Check Angular version. + (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, rxjs_1.concatMap)(({ config, i18n, projectRoot, projectSourceRoot }) => { + return (0, build_webpack_1.runWebpack)(config, context, { + webpackFactory: require('webpack'), + logging: (stats, config) => { + if (options.verbose) { + context.logger.info(stats.toString(config.stats)); + } + }, + }).pipe((0, rxjs_1.concatMap)(async (output) => { + const { emittedFiles = [], outputPath, webpackStats, success } = output; + if (!webpackStats) { + throw new Error('Webpack stats build result is required.'); + } + if (!success) { + if ((0, stats_1.statsHasWarnings)(webpackStats)) { + context.logger.warn((0, stats_1.statsWarningsToString)(webpackStats, { colors: true })); + } + if ((0, stats_1.statsHasErrors)(webpackStats)) { + context.logger.error((0, stats_1.statsErrorsToString)(webpackStats, { colors: true })); + } + 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 && options.assets?.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; + })); + }), (0, rxjs_1.concatMap)(async (output) => { + if (!output.success) { + return output; + } + return { + ...output, + baseOutputPath, + outputs: (outputPaths && + [...outputPaths.entries()].map(([locale, path]) => ({ + locale, + path, + }))) || { + path: baseOutputPath, + }, + }; + })); +} +exports.execute = execute; +exports.default = (0, architect_1.createBuilder)(execute); +async function initialize(options, context, webpackConfigurationTransform) { + // Purge old build disk cache. + await (0, purge_cache_1.purgeStaleBuildCache)(context); + await checkTsConfigForPreserveWhitespacesSetting(context, options.tsConfig); + const browserslist = (await Promise.resolve().then(() => __importStar(require('browserslist')))).default; + const originalOutputPath = options.outputPath; + // 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, + aot: true, + platform: 'server', + }, context, (wco) => { + var _a; + // We use the platform to determine the JavaScript syntax output. + (_a = wco.buildOptions).supportedBrowsers ?? (_a.supportedBrowsers = []); + wco.buildOptions.supportedBrowsers.push(...browserslist('maintained node versions')); + return [getPlatformServerExportsConfig(wco), (0, configs_1.getCommonConfig)(wco), (0, configs_1.getStylesConfig)(wco)]; + }); + if (options.deleteOutputPath) { + (0, utils_1.deleteOutputDir)(context.workspaceRoot, originalOutputPath); + } + const transformedConfig = (await webpackConfigurationTransform?.(config)) ?? config; + return { config: transformedConfig, i18n, projectRoot, projectSourceRoot }; +} +async function checkTsConfigForPreserveWhitespacesSetting(context, tsConfigPath) { + // We don't use the `readTsConfig` method on purpose here. + // To only catch cases were `preserveWhitespaces` is set directly in the `tsconfig.server.json`, + // which in the majority of cases will cause a mistmatch between client and server builds. + // Technically we should check if `tsconfig.server.json` and `tsconfig.app.json` values match. + // But: + // 1. It is not guaranteed that `tsconfig.app.json` is used to build the client side of this app. + // 2. There is no easy way to access the build build config from the server builder. + // 4. This will no longer be an issue with a single compilation model were the same tsconfig is used for both browser and server builds. + const content = await (0, promises_1.readFile)(path.join(context.workspaceRoot, tsConfigPath), 'utf-8'); + const { parse } = await Promise.resolve().then(() => __importStar(require('jsonc-parser'))); + const tsConfig = parse(content, [], { allowTrailingComma: true }); + if (tsConfig.angularCompilerOptions?.preserveWhitespaces !== undefined) { + context.logger.warn(`"preserveWhitespaces" was set in "${tsConfigPath}". ` + + 'Make sure that this setting is set consistently in both "tsconfig.server.json" for your server side ' + + 'and "tsconfig.app.json" for your client side. A mismatched value will cause hydration to break.\n' + + 'For more information see: https://angular.io/guide/hydration#preserve-whitespaces'); + } +} +/** + * Add `@angular/platform-server` exports. + * This is needed so that DI tokens can be referenced and set at runtime outside of the bundle. + */ +function getPlatformServerExportsConfig(wco) { + // Add `@angular/platform-server` exports. + // This is needed so that DI tokens can be referenced and set at runtime outside of the bundle. + // Only add `@angular/platform-server` exports when it is installed. + // In some cases this builder is used when `@angular/platform-server` is not installed. + // Example: when using `@nguniversal/common/clover` which does not need `@angular/platform-server`. + return (0, helpers_1.isPlatformServerInstalled)(wco.root) + ? { + module: { + rules: [ + { + loader: require.resolve('./platform-server-exports-loader'), + include: [path.resolve(wco.root, wco.buildOptions.main)], + }, + ], + }, + } + : {}; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/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 { BuilderContext, BuilderOutput, createBuilder } from '@angular-devkit/architect';\nimport { runWebpack } from '@angular-devkit/build-webpack';\nimport { readFile } from 'node:fs/promises';\nimport * as path from 'node:path';\nimport { Observable, concatMap, from } from 'rxjs';\nimport webpack, { Configuration } from 'webpack';\nimport { ExecutionTransformer } from '../../transforms';\nimport {\n  NormalizedBrowserBuilderSchema,\n  deleteOutputDir,\n  normalizeAssetPatterns,\n} from '../../utils';\nimport { colors } from '../../utils/color';\nimport { copyAssets } from '../../utils/copy-assets';\nimport { assertIsError } from '../../utils/error';\nimport { i18nInlineEmittedFiles } from '../../utils/i18n-inlining';\nimport { I18nOptions } from '../../utils/i18n-options';\nimport { ensureOutputPaths } from '../../utils/output-paths';\nimport { purgeStaleBuildCache } from '../../utils/purge-cache';\nimport { Spinner } from '../../utils/spinner';\nimport { assertCompatibleAngularVersion } from '../../utils/version';\nimport {\n  BrowserWebpackConfigOptions,\n  generateI18nBrowserWebpackConfigFromContext,\n} from '../../utils/webpack-browser-config';\nimport { getCommonConfig, getStylesConfig } from '../../webpack/configs';\nimport { isPlatformServerInstalled } from '../../webpack/utils/helpers';\nimport {\n  statsErrorsToString,\n  statsHasErrors,\n  statsHasWarnings,\n  statsWarningsToString,\n  webpackStatsLogger,\n} from '../../webpack/utils/stats';\nimport { Schema as ServerBuilderOptions } from './schema';\n\n/**\n * @experimental Direct usage of this type is considered experimental.\n */\nexport type ServerBuilderOutput = BuilderOutput & {\n  baseOutputPath: string;\n  outputPath: string;\n  outputs: {\n    locale?: string;\n    path: string;\n  }[];\n};\n\nexport { ServerBuilderOptions };\n\n/**\n * @experimental Direct usage of this function is considered experimental.\n */\nexport function execute(\n  options: ServerBuilderOptions,\n  context: BuilderContext,\n  transforms: {\n    webpackConfiguration?: ExecutionTransformer<webpack.Configuration>;\n  } = {},\n): Observable<ServerBuilderOutput> {\n  const root = context.workspaceRoot;\n\n  // Check Angular version.\n  assertCompatibleAngularVersion(root);\n\n  const baseOutputPath = path.resolve(root, options.outputPath);\n  let outputPaths: undefined | Map<string, string>;\n\n  return from(initialize(options, context, transforms.webpackConfiguration)).pipe(\n    concatMap(({ config, i18n, projectRoot, projectSourceRoot }) => {\n      return runWebpack(config, context, {\n        webpackFactory: require('webpack') as typeof webpack,\n        logging: (stats, config) => {\n          if (options.verbose) {\n            context.logger.info(stats.toString(config.stats));\n          }\n        },\n      }).pipe(\n        concatMap(async (output) => {\n          const { emittedFiles = [], outputPath, webpackStats, success } = output;\n          if (!webpackStats) {\n            throw new Error('Webpack stats build result is required.');\n          }\n\n          if (!success) {\n            if (statsHasWarnings(webpackStats)) {\n              context.logger.warn(statsWarningsToString(webpackStats, { colors: true }));\n            }\n            if (statsHasErrors(webpackStats)) {\n              context.logger.error(statsErrorsToString(webpackStats, { colors: true }));\n            }\n\n            return output;\n          }\n\n          const spinner = new Spinner();\n          spinner.enabled = options.progress !== false;\n          outputPaths = ensureOutputPaths(baseOutputPath, i18n);\n\n          // Copy assets\n          if (!options.watch && options.assets?.length) {\n            spinner.start('Copying assets...');\n            try {\n              await copyAssets(\n                normalizeAssetPatterns(\n                  options.assets,\n                  context.workspaceRoot,\n                  projectRoot,\n                  projectSourceRoot,\n                ),\n                Array.from(outputPaths.values()),\n                context.workspaceRoot,\n              );\n              spinner.succeed('Copying assets complete.');\n            } catch (err) {\n              spinner.fail(colors.redBright('Copying of assets failed.'));\n              assertIsError(err);\n\n              return {\n                ...output,\n                success: false,\n                error: 'Unable to copy assets: ' + err.message,\n              };\n            }\n          }\n\n          if (i18n.shouldInline) {\n            const success = await i18nInlineEmittedFiles(\n              context,\n              emittedFiles,\n              i18n,\n              baseOutputPath,\n              Array.from(outputPaths.values()),\n              [],\n              outputPath,\n              options.i18nMissingTranslation,\n            );\n            if (!success) {\n              return {\n                ...output,\n                success: false,\n              };\n            }\n          }\n\n          webpackStatsLogger(context.logger, webpackStats, config);\n\n          return output;\n        }),\n      );\n    }),\n    concatMap(async (output) => {\n      if (!output.success) {\n        return output as ServerBuilderOutput;\n      }\n\n      return {\n        ...output,\n        baseOutputPath,\n        outputs: (outputPaths &&\n          [...outputPaths.entries()].map(([locale, path]) => ({\n            locale,\n            path,\n          }))) || {\n          path: baseOutputPath,\n        },\n      } as ServerBuilderOutput;\n    }),\n  );\n}\n\nexport default createBuilder<ServerBuilderOptions, ServerBuilderOutput>(execute);\n\nasync function initialize(\n  options: ServerBuilderOptions,\n  context: BuilderContext,\n  webpackConfigurationTransform?: ExecutionTransformer<webpack.Configuration>,\n): Promise<{\n  config: webpack.Configuration;\n  i18n: I18nOptions;\n  projectRoot: string;\n  projectSourceRoot?: string;\n}> {\n  // Purge old build disk cache.\n  await purgeStaleBuildCache(context);\n\n  await checkTsConfigForPreserveWhitespacesSetting(context, options.tsConfig);\n\n  const browserslist = (await import('browserslist')).default;\n  const originalOutputPath = options.outputPath;\n  // Assets are processed directly by the builder except when watching\n  const adjustedOptions = options.watch ? options : { ...options, assets: [] };\n\n  const { config, projectRoot, projectSourceRoot, i18n } =\n    await generateI18nBrowserWebpackConfigFromContext(\n      {\n        ...adjustedOptions,\n        aot: true,\n        platform: 'server',\n      } as NormalizedBrowserBuilderSchema,\n      context,\n      (wco) => {\n        // We use the platform to determine the JavaScript syntax output.\n        wco.buildOptions.supportedBrowsers ??= [];\n        wco.buildOptions.supportedBrowsers.push(...browserslist('maintained node versions'));\n\n        return [getPlatformServerExportsConfig(wco), getCommonConfig(wco), getStylesConfig(wco)];\n      },\n    );\n\n  if (options.deleteOutputPath) {\n    deleteOutputDir(context.workspaceRoot, originalOutputPath);\n  }\n\n  const transformedConfig = (await webpackConfigurationTransform?.(config)) ?? config;\n\n  return { config: transformedConfig, i18n, projectRoot, projectSourceRoot };\n}\n\nasync function checkTsConfigForPreserveWhitespacesSetting(\n  context: BuilderContext,\n  tsConfigPath: string,\n): Promise<void> {\n  // We don't use the `readTsConfig` method on purpose here.\n  // To only catch cases were `preserveWhitespaces` is set directly in the `tsconfig.server.json`,\n  // which in the majority of cases will cause a mistmatch between client and server builds.\n  // Technically we should check if `tsconfig.server.json` and `tsconfig.app.json` values match.\n\n  // But:\n  // 1. It is not guaranteed that `tsconfig.app.json` is used to build the client side of this app.\n  // 2. There is no easy way to access the build build config from the server builder.\n  // 4. This will no longer be an issue with a single compilation model were the same tsconfig is used for both browser and server builds.\n  const content = await readFile(path.join(context.workspaceRoot, tsConfigPath), 'utf-8');\n  const { parse } = await import('jsonc-parser');\n  const tsConfig = parse(content, [], { allowTrailingComma: true });\n  if (tsConfig.angularCompilerOptions?.preserveWhitespaces !== undefined) {\n    context.logger.warn(\n      `\"preserveWhitespaces\" was set in \"${tsConfigPath}\". ` +\n        'Make sure that this setting is set consistently in both \"tsconfig.server.json\" for your server side ' +\n        'and \"tsconfig.app.json\" for your client side. A mismatched value will cause hydration to break.\\n' +\n        'For more information see: https://angular.io/guide/hydration#preserve-whitespaces',\n    );\n  }\n}\n\n/**\n * Add `@angular/platform-server` exports.\n * This is needed so that DI tokens can be referenced and set at runtime outside of the bundle.\n */\nfunction getPlatformServerExportsConfig(wco: BrowserWebpackConfigOptions): Partial<Configuration> {\n  // Add `@angular/platform-server` exports.\n  // This is needed so that DI tokens can be referenced and set at runtime outside of the bundle.\n\n  // Only add `@angular/platform-server` exports when it is installed.\n  // In some cases this builder is used when `@angular/platform-server` is not installed.\n  // Example: when using `@nguniversal/common/clover` which does not need `@angular/platform-server`.\n\n  return isPlatformServerInstalled(wco.root)\n    ? {\n        module: {\n          rules: [\n            {\n              loader: require.resolve('./platform-server-exports-loader'),\n              include: [path.resolve(wco.root, wco.buildOptions.main)],\n            },\n          ],\n        },\n      }\n    : {};\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/server/platform-server-exports-loader.d.ts b/artifacts/build-angular/src/builders/server/platform-server-exports-loader.d.ts new file mode 100644 index 00000000..c5750694 --- /dev/null +++ b/artifacts/build-angular/src/builders/server/platform-server-exports-loader.d.ts @@ -0,0 +1,13 @@ +/** + * @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 + */ +/** + * This loader is needed to add additional exports and is a workaround for a Webpack bug that doesn't + * allow exports from multiple files in the same entry. + * @see https://github.com/webpack/webpack/issues/15936. + */ +export default function (this: import('webpack').LoaderContext<{}>, content: string, map: Parameters[1]): void; diff --git a/artifacts/build-angular/src/builders/server/platform-server-exports-loader.js b/artifacts/build-angular/src/builders/server/platform-server-exports-loader.js new file mode 100644 index 00000000..a5f231ca --- /dev/null +++ b/artifacts/build-angular/src/builders/server/platform-server-exports-loader.js @@ -0,0 +1,25 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +/** + * This loader is needed to add additional exports and is a workaround for a Webpack bug that doesn't + * allow exports from multiple files in the same entry. + * @see https://github.com/webpack/webpack/issues/15936. + */ +function default_1(content, map) { + const source = `${content} + + // EXPORTS added by @angular-devkit/build-angular + export { renderApplication, renderModule, ɵSERVER_CONTEXT } from '@angular/platform-server'; + `; + this.callback(null, source, map); + return; +} +exports.default = default_1; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGxhdGZvcm0tc2VydmVyLWV4cG9ydHMtbG9hZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvYW5ndWxhcl9kZXZraXQvYnVpbGRfYW5ndWxhci9zcmMvYnVpbGRlcnMvc2VydmVyL3BsYXRmb3JtLXNlcnZlci1leHBvcnRzLWxvYWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7OztHQU1HOztBQUVIOzs7O0dBSUc7QUFDSCxtQkFFRSxPQUFlLEVBQ2YsR0FBOEQ7SUFFOUQsTUFBTSxNQUFNLEdBQUcsR0FBRyxPQUFPOzs7O0dBSXhCLENBQUM7SUFFRixJQUFJLENBQUMsUUFBUSxDQUFDLElBQUksRUFBRSxNQUFNLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFFakMsT0FBTztBQUNULENBQUM7QUFkRCw0QkFjQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG4vKipcbiAqIFRoaXMgbG9hZGVyIGlzIG5lZWRlZCB0byBhZGQgYWRkaXRpb25hbCBleHBvcnRzIGFuZCBpcyBhIHdvcmthcm91bmQgZm9yIGEgV2VicGFjayBidWcgdGhhdCBkb2Vzbid0XG4gKiBhbGxvdyBleHBvcnRzIGZyb20gbXVsdGlwbGUgZmlsZXMgaW4gdGhlIHNhbWUgZW50cnkuXG4gKiBAc2VlIGh0dHBzOi8vZ2l0aHViLmNvbS93ZWJwYWNrL3dlYnBhY2svaXNzdWVzLzE1OTM2LlxuICovXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiAoXG4gIHRoaXM6IGltcG9ydCgnd2VicGFjaycpLkxvYWRlckNvbnRleHQ8e30+LFxuICBjb250ZW50OiBzdHJpbmcsXG4gIG1hcDogUGFyYW1ldGVyczxpbXBvcnQoJ3dlYnBhY2snKS5Mb2FkZXJEZWZpbml0aW9uRnVuY3Rpb24+WzFdLFxuKSB7XG4gIGNvbnN0IHNvdXJjZSA9IGAke2NvbnRlbnR9XG5cbiAgLy8gRVhQT1JUUyBhZGRlZCBieSBAYW5ndWxhci1kZXZraXQvYnVpbGQtYW5ndWxhclxuICBleHBvcnQgeyByZW5kZXJBcHBsaWNhdGlvbiwgcmVuZGVyTW9kdWxlLCDJtVNFUlZFUl9DT05URVhUIH0gZnJvbSAnQGFuZ3VsYXIvcGxhdGZvcm0tc2VydmVyJztcbiAgYDtcblxuICB0aGlzLmNhbGxiYWNrKG51bGwsIHNvdXJjZSwgbWFwKTtcblxuICByZXR1cm47XG59XG4iXX0= \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/server/schema.d.ts b/artifacts/build-angular/src/builders/server/schema.d.ts new file mode 100644 index 00000000..3861a7a9 --- /dev/null +++ b/artifacts/build-angular/src/builders/server/schema.d.ts @@ -0,0 +1,230 @@ +export interface Schema { + /** + * List of static application assets. + */ + assets?: AssetPattern[]; + /** + * Enables advanced build optimizations. + */ + buildOptimizer?: boolean; + /** + * Delete the output path before building. + */ + deleteOutputPath?: boolean; + /** + * URL where files will be deployed. + * @deprecated Use "baseHref" browser builder option, "APP_BASE_HREF" DI token or a + * combination of both instead. For more information, see + * https://angular.io/guide/deployment#the-deploy-url. + */ + deployUrl?: string; + /** + * Exclude the listed external dependencies from being bundled into the bundle. Instead, the + * created bundle relies on these dependencies to be available during runtime. + */ + externalDependencies?: string[]; + /** + * Extract all licenses in a separate file, in the case of production builds only. + */ + extractLicenses?: boolean; + /** + * Replace compilation source files with other compilation source files in the build. + */ + fileReplacements?: FileReplacement[]; + /** + * How to handle duplicate translations for i18n. + */ + i18nDuplicateTranslation?: I18NTranslation; + /** + * How to handle missing translations for i18n. + */ + i18nMissingTranslation?: I18NTranslation; + /** + * The stylesheet language to use for the application's inline component styles. + */ + inlineStyleLanguage?: InlineStyleLanguage; + /** + * Translate the bundles in one or more locales. + */ + localize?: Localize; + /** + * The name of the main entry-point file. + */ + main: string; + /** + * Use file name for lazy loaded chunks. + */ + namedChunks?: boolean; + /** + * Enables optimization of the build output. Including minification of scripts and styles, + * tree-shaking and dead-code elimination. For more information, see + * https://angular.io/guide/workspace-config#optimization-configuration. + */ + optimization?: OptimizationUnion; + /** + * Define the output filename cache-busting hashing mode. + */ + outputHashing?: OutputHashing; + /** + * Path where output will be placed. + */ + outputPath: string; + /** + * Enable and define the file watching poll time period in milliseconds. + */ + poll?: number; + /** + * Do not use the real path when resolving modules. If unset then will default to `true` if + * NodeJS option --preserve-symlinks is set. + */ + preserveSymlinks?: boolean; + /** + * Log progress to the console while building. + */ + progress?: boolean; + /** + * The path where style resources will be placed, relative to outputPath. + */ + resourcesOutputPath?: string; + /** + * Output source maps for scripts and styles. For more information, see + * https://angular.io/guide/workspace-config#source-map-configuration. + */ + sourceMap?: SourceMapUnion; + /** + * Generates a 'stats.json' file which can be analyzed using tools such as + * 'webpack-bundle-analyzer'. + */ + statsJson?: boolean; + /** + * Options to pass to style preprocessors + */ + stylePreprocessorOptions?: StylePreprocessorOptions; + /** + * The name of the TypeScript configuration file. + */ + tsConfig: string; + /** + * Generate a seperate bundle containing only vendor libraries. This option should only be + * used for development to reduce the incremental compilation time. + */ + vendorChunk?: boolean; + /** + * Adds more details to output logging. + */ + verbose?: boolean; + /** + * Run build when files change. + */ + watch?: boolean; +} +export 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; + src?: string; + with?: string; +} +/** + * How to handle duplicate translations for i18n. + * + * How to handle missing translations for i18n. + */ +export declare enum I18NTranslation { + Error = "error", + Ignore = "ignore", + Warning = "warning" +} +/** + * The stylesheet language to use for the application's inline component styles. + */ +export declare enum InlineStyleLanguage { + Css = "css", + Less = "less", + Sass = "sass", + Scss = "scss" +} +/** + * Translate the bundles in one or more locales. + */ +export type Localize = string[] | boolean; +/** + * Enables optimization of the build output. Including minification of scripts and styles, + * tree-shaking and dead-code elimination. For more information, see + * https://angular.io/guide/workspace-config#optimization-configuration. + */ +export type OptimizationUnion = boolean | OptimizationClass; +export interface OptimizationClass { + /** + * Enables optimization of the scripts output. + */ + scripts?: boolean; + /** + * Enables optimization of the styles output. + */ + styles?: boolean; +} +/** + * Define the output filename cache-busting hashing mode. + */ +export declare enum OutputHashing { + All = "all", + Bundles = "bundles", + Media = "media", + None = "none" +} +/** + * Output source maps for scripts and styles. For more information, see + * https://angular.io/guide/workspace-config#source-map-configuration. + */ +export type SourceMapUnion = boolean | SourceMapClass; +export interface SourceMapClass { + /** + * Output source maps used for error reporting tools. + */ + hidden?: boolean; + /** + * Output source maps for all scripts. + */ + scripts?: boolean; + /** + * Output source maps for all styles. + */ + styles?: boolean; + /** + * Resolve vendor packages source maps. + */ + vendor?: boolean; +} +/** + * Options to pass to style preprocessors + */ +export interface StylePreprocessorOptions { + /** + * Paths to include. Paths will be resolved to workspace root. + */ + includePaths?: string[]; +} diff --git a/artifacts/build-angular/src/builders/server/schema.js b/artifacts/build-angular/src/builders/server/schema.js new file mode 100644 index 00000000..c3485382 --- /dev/null +++ b/artifacts/build-angular/src/builders/server/schema.js @@ -0,0 +1,37 @@ +"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 }); +exports.OutputHashing = exports.InlineStyleLanguage = exports.I18NTranslation = void 0; +/** + * How to handle duplicate translations for i18n. + * + * How to handle missing translations for i18n. + */ +var I18NTranslation; +(function (I18NTranslation) { + I18NTranslation["Error"] = "error"; + I18NTranslation["Ignore"] = "ignore"; + I18NTranslation["Warning"] = "warning"; +})(I18NTranslation = exports.I18NTranslation || (exports.I18NTranslation = {})); +/** + * The stylesheet language to use for the application's inline component styles. + */ +var InlineStyleLanguage; +(function (InlineStyleLanguage) { + InlineStyleLanguage["Css"] = "css"; + InlineStyleLanguage["Less"] = "less"; + InlineStyleLanguage["Sass"] = "sass"; + InlineStyleLanguage["Scss"] = "scss"; +})(InlineStyleLanguage = exports.InlineStyleLanguage || (exports.InlineStyleLanguage = {})); +/** + * Define the output filename cache-busting hashing mode. + */ +var OutputHashing; +(function (OutputHashing) { + OutputHashing["All"] = "all"; + OutputHashing["Bundles"] = "bundles"; + OutputHashing["Media"] = "media"; + OutputHashing["None"] = "none"; +})(OutputHashing = exports.OutputHashing || (exports.OutputHashing = {})); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/server/schema.ts"],"names":[],"mappings":";AACA,mFAAmF;AACnF,oFAAoF;;;AA4JpF;;;;GAIG;AACH,IAAY,eAIX;AAJD,WAAY,eAAe;IACvB,kCAAe,CAAA;IACf,oCAAiB,CAAA;IACjB,sCAAmB,CAAA;AACvB,CAAC,EAJW,eAAe,GAAf,uBAAe,KAAf,uBAAe,QAI1B;AAED;;GAEG;AACH,IAAY,mBAKX;AALD,WAAY,mBAAmB;IAC3B,kCAAW,CAAA;IACX,oCAAa,CAAA;IACb,oCAAa,CAAA;IACb,oCAAa,CAAA;AACjB,CAAC,EALW,mBAAmB,GAAnB,2BAAmB,KAAnB,2BAAmB,QAK9B;AAyBD;;GAEG;AACH,IAAY,aAKX;AALD,WAAY,aAAa;IACrB,4BAAW,CAAA;IACX,oCAAmB,CAAA;IACnB,gCAAe,CAAA;IACf,8BAAa,CAAA;AACjB,CAAC,EALW,aAAa,GAAb,qBAAa,KAAb,qBAAa,QAKxB","sourcesContent":["\n// THIS FILE IS AUTOMATICALLY GENERATED. TO UPDATE THIS FILE YOU NEED TO CHANGE THE\n// CORRESPONDING JSON SCHEMA FILE, THEN RUN devkit-admin build (or bazel build ...).\n\nexport interface Schema {\n    /**\n     * List of static application assets.\n     */\n    assets?: AssetPattern[];\n    /**\n     * Enables advanced build optimizations.\n     */\n    buildOptimizer?: boolean;\n    /**\n     * Delete the output path before building.\n     */\n    deleteOutputPath?: boolean;\n    /**\n     * URL where files will be deployed.\n     * @deprecated Use \"baseHref\" browser builder option, \"APP_BASE_HREF\" DI token or a\n     * combination of both instead. For more information, see\n     * https://angular.io/guide/deployment#the-deploy-url.\n     */\n    deployUrl?: string;\n    /**\n     * Exclude the listed external dependencies from being bundled into the bundle. Instead, the\n     * created bundle relies on these dependencies to be available during runtime.\n     */\n    externalDependencies?: string[];\n    /**\n     * Extract all licenses in a separate file, in the case of production builds only.\n     */\n    extractLicenses?: boolean;\n    /**\n     * Replace compilation source files with other compilation source files in the build.\n     */\n    fileReplacements?: FileReplacement[];\n    /**\n     * How to handle duplicate translations for i18n.\n     */\n    i18nDuplicateTranslation?: I18NTranslation;\n    /**\n     * How to handle missing translations for i18n.\n     */\n    i18nMissingTranslation?: I18NTranslation;\n    /**\n     * The stylesheet language to use for the application's inline component styles.\n     */\n    inlineStyleLanguage?: InlineStyleLanguage;\n    /**\n     * Translate the bundles in one or more locales.\n     */\n    localize?: Localize;\n    /**\n     * The name of the main entry-point file.\n     */\n    main: string;\n    /**\n     * Use file name for lazy loaded chunks.\n     */\n    namedChunks?: boolean;\n    /**\n     * Enables optimization of the build output. Including minification of scripts and styles,\n     * tree-shaking and dead-code elimination. For more information, see\n     * https://angular.io/guide/workspace-config#optimization-configuration.\n     */\n    optimization?: OptimizationUnion;\n    /**\n     * Define the output filename cache-busting hashing mode.\n     */\n    outputHashing?: OutputHashing;\n    /**\n     * Path where output will be placed.\n     */\n    outputPath: string;\n    /**\n     * Enable and define the file watching poll time period in milliseconds.\n     */\n    poll?: number;\n    /**\n     * Do not use the real path when resolving modules. If unset then will default to `true` if\n     * NodeJS option --preserve-symlinks is set.\n     */\n    preserveSymlinks?: boolean;\n    /**\n     * Log progress to the console while building.\n     */\n    progress?: boolean;\n    /**\n     * The path where style resources will be placed, relative to outputPath.\n     */\n    resourcesOutputPath?: string;\n    /**\n     * Output source maps for scripts and styles. For more information, see\n     * https://angular.io/guide/workspace-config#source-map-configuration.\n     */\n    sourceMap?: SourceMapUnion;\n    /**\n     * Generates a 'stats.json' file which can be analyzed using tools such as\n     * 'webpack-bundle-analyzer'.\n     */\n    statsJson?: boolean;\n    /**\n     * Options to pass to style preprocessors\n     */\n    stylePreprocessorOptions?: StylePreprocessorOptions;\n    /**\n     * The name of the TypeScript configuration file.\n     */\n    tsConfig: string;\n    /**\n     * Generate a seperate bundle containing only vendor libraries. This option should only be\n     * used for development to reduce the incremental compilation time.\n     */\n    vendorChunk?: boolean;\n    /**\n     * Adds more details to output logging.\n     */\n    verbose?: boolean;\n    /**\n     * Run build when files change.\n     */\n    watch?: boolean;\n}\n\nexport type AssetPattern = AssetPatternClass | string;\n\nexport interface AssetPatternClass {\n    /**\n     * Allow glob patterns to follow symlink directories. This allows subdirectories of the\n     * symlink to be searched.\n     */\n    followSymlinks?: boolean;\n    /**\n     * The pattern to match.\n     */\n    glob: string;\n    /**\n     * An array of globs to ignore.\n     */\n    ignore?: string[];\n    /**\n     * The input directory path in which to apply 'glob'. Defaults to the project root.\n     */\n    input: string;\n    /**\n     * Absolute path within the output.\n     */\n    output: string;\n}\n\nexport interface FileReplacement {\n    replace?:     string;\n    replaceWith?: string;\n    src?:         string;\n    with?:        string;\n}\n\n/**\n * How to handle duplicate translations for i18n.\n *\n * How to handle missing translations for i18n.\n */\nexport enum I18NTranslation {\n    Error = \"error\",\n    Ignore = \"ignore\",\n    Warning = \"warning\",\n}\n\n/**\n * The stylesheet language to use for the application's inline component styles.\n */\nexport enum InlineStyleLanguage {\n    Css = \"css\",\n    Less = \"less\",\n    Sass = \"sass\",\n    Scss = \"scss\",\n}\n\n/**\n * Translate the bundles in one or more locales.\n */\nexport type Localize = string[] | boolean;\n\n/**\n * Enables optimization of the build output. Including minification of scripts and styles,\n * tree-shaking and dead-code elimination. For more information, see\n * https://angular.io/guide/workspace-config#optimization-configuration.\n */\nexport type OptimizationUnion = boolean | OptimizationClass;\n\nexport interface OptimizationClass {\n    /**\n     * Enables optimization of the scripts output.\n     */\n    scripts?: boolean;\n    /**\n     * Enables optimization of the styles output.\n     */\n    styles?: boolean;\n}\n\n/**\n * Define the output filename cache-busting hashing mode.\n */\nexport enum OutputHashing {\n    All = \"all\",\n    Bundles = \"bundles\",\n    Media = \"media\",\n    None = \"none\",\n}\n\n/**\n * Output source maps for scripts and styles. For more information, see\n * https://angular.io/guide/workspace-config#source-map-configuration.\n */\nexport type SourceMapUnion = boolean | SourceMapClass;\n\nexport interface SourceMapClass {\n    /**\n     * Output source maps used for error reporting tools.\n     */\n    hidden?: boolean;\n    /**\n     * Output source maps for all scripts.\n     */\n    scripts?: boolean;\n    /**\n     * Output source maps for all styles.\n     */\n    styles?: boolean;\n    /**\n     * Resolve vendor packages source maps.\n     */\n    vendor?: boolean;\n}\n\n/**\n * Options to pass to style preprocessors\n */\nexport interface StylePreprocessorOptions {\n    /**\n     * Paths to include. Paths will be resolved to workspace root.\n     */\n    includePaths?: string[];\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/builders/server/schema.json b/artifacts/build-angular/src/builders/server/schema.json new file mode 100644 index 00000000..a18c4687 --- /dev/null +++ b/artifacts/build-angular/src/builders/server/schema.json @@ -0,0 +1,301 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema", + "$id": "BuildAngularWebpackServerSchema", + "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." + }, + "tsConfig": { + "type": "string", + "default": "tsconfig.app.json", + "description": "The name of the TypeScript configuration file." + }, + "inlineStyleLanguage": { + "description": "The stylesheet language to use for the application's inline component styles.", + "type": "string", + "default": "css", + "enum": ["css", "less", "sass", "scss"] + }, + "stylePreprocessorOptions": { + "description": "Options to pass to style preprocessors", + "type": "object", + "properties": { + "includePaths": { + "description": "Paths to include. Paths will be resolved to workspace root.", + "type": "array", + "items": { + "type": "string" + }, + "default": [] + } + }, + "additionalProperties": false + }, + "optimization": { + "description": "Enables optimization of the build output. Including minification of scripts and styles, tree-shaking and dead-code elimination. For more information, see https://angular.io/guide/workspace-config#optimization-configuration.", + "default": true, + "x-user-analytics": "ep.ng_optimization", + "oneOf": [ + { + "type": "object", + "properties": { + "scripts": { + "type": "boolean", + "description": "Enables optimization of the scripts output.", + "default": true + }, + "styles": { + "type": "boolean", + "description": "Enables optimization of the styles output.", + "default": true + } + }, + "additionalProperties": false + }, + { + "type": "boolean" + } + ] + }, + "fileReplacements": { + "description": "Replace compilation source files with other compilation source files in the build.", + "type": "array", + "items": { + "$ref": "#/definitions/fileReplacement" + }, + "default": [] + }, + "outputPath": { + "type": "string", + "description": "Path where output will be placed." + }, + "resourcesOutputPath": { + "type": "string", + "description": "The path where style resources will be placed, relative to outputPath." + }, + "sourceMap": { + "description": "Output source maps for scripts and styles. For more information, see https://angular.io/guide/workspace-config#source-map-configuration.", + "default": false, + "oneOf": [ + { + "type": "object", + "properties": { + "scripts": { + "type": "boolean", + "description": "Output source maps for all scripts.", + "default": true + }, + "styles": { + "type": "boolean", + "description": "Output source maps for all styles.", + "default": true + }, + "hidden": { + "type": "boolean", + "description": "Output source maps used for error reporting tools.", + "default": false + }, + "vendor": { + "type": "boolean", + "description": "Resolve vendor packages source maps.", + "default": false + } + }, + "additionalProperties": false + }, + { + "type": "boolean" + } + ] + }, + "deployUrl": { + "type": "string", + "description": "URL where files will be deployed.", + "x-deprecated": "Use \"baseHref\" browser builder option, \"APP_BASE_HREF\" DI token or a combination of both instead. For more information, see https://angular.io/guide/deployment#the-deploy-url." + }, + "vendorChunk": { + "type": "boolean", + "description": "Generate a seperate bundle containing only vendor libraries. This option should only be used for development to reduce the incremental compilation time.", + "default": false + }, + "verbose": { + "type": "boolean", + "description": "Adds more details to output logging.", + "default": false + }, + "progress": { + "type": "boolean", + "description": "Log progress to the console while building.", + "default": true + }, + "i18nMissingTranslation": { + "type": "string", + "description": "How to handle missing translations for i18n.", + "enum": ["warning", "error", "ignore"], + "default": "warning" + }, + "i18nDuplicateTranslation": { + "type": "string", + "description": "How to handle duplicate translations for i18n.", + "enum": ["warning", "error", "ignore"], + "default": "warning" + }, + "localize": { + "description": "Translate the bundles in one or more locales.", + "oneOf": [ + { + "type": "boolean", + "description": "Translate all locales." + }, + { + "type": "array", + "description": "List of locales ID's to translate.", + "minItems": 1, + "items": { + "type": "string", + "pattern": "^[a-zA-Z]{2,3}(-[a-zA-Z]{4})?(-([a-zA-Z]{2}|[0-9]{3}))?(-[a-zA-Z]{5,8})?(-x(-[a-zA-Z0-9]{1,8})+)?$" + } + } + ] + }, + "outputHashing": { + "type": "string", + "description": "Define the output filename cache-busting hashing mode.", + "default": "none", + "enum": ["none", "all", "media", "bundles"] + }, + "deleteOutputPath": { + "type": "boolean", + "description": "Delete the output path before building.", + "default": true + }, + "preserveSymlinks": { + "type": "boolean", + "description": "Do not use the real path when resolving modules. If unset then will default to `true` if NodeJS option --preserve-symlinks is set." + }, + "extractLicenses": { + "type": "boolean", + "description": "Extract all licenses in a separate file, in the case of production builds only.", + "default": true + }, + "buildOptimizer": { + "type": "boolean", + "description": "Enables advanced build optimizations.", + "default": true + }, + "namedChunks": { + "type": "boolean", + "description": "Use file name for lazy loaded chunks.", + "default": false + }, + "externalDependencies": { + "description": "Exclude the listed external dependencies from being bundled into the bundle. Instead, the created bundle relies on these dependencies to be available during runtime.", + "type": "array", + "items": { + "type": "string" + }, + "default": [] + }, + "statsJson": { + "type": "boolean", + "description": "Generates a 'stats.json' file which can be analyzed using tools such as 'webpack-bundle-analyzer'.", + "default": false + }, + "watch": { + "type": "boolean", + "description": "Run build when files change.", + "default": false + }, + "poll": { + "type": "number", + "description": "Enable and define the file watching poll time period in milliseconds." + } + }, + "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": [ + { + "type": "object", + "properties": { + "src": { + "type": "string", + "pattern": "\\.(([cm]?j|t)sx?|json)$" + }, + "replaceWith": { + "type": "string", + "pattern": "\\.(([cm]?j|t)sx?|json)$" + } + }, + "additionalProperties": false, + "required": ["src", "replaceWith"] + }, + { + "type": "object", + "properties": { + "replace": { + "type": "string", + "pattern": "\\.(([cm]?j|t)sx?|json)$" + }, + "with": { + "type": "string", + "pattern": "\\.(([cm]?j|t)sx?|json)$" + } + }, + "additionalProperties": false, + "required": ["replace", "with"] + } + ] + } + } +} diff --git a/artifacts/build-angular/src/index.d.ts b/artifacts/build-angular/src/index.d.ts new file mode 100644 index 00000000..9125576d --- /dev/null +++ b/artifacts/build-angular/src/index.d.ts @@ -0,0 +1,16 @@ +/** + * @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 + */ +export * from './transforms'; +export { AssetPattern, AssetPatternClass as AssetPatternObject, Budget, CrossOrigin, FileReplacement, OptimizationClass as OptimizationObject, OptimizationUnion, OutputHashing, Schema as BrowserBuilderOptions, SourceMapClass as SourceMapObject, SourceMapUnion, StylePreprocessorOptions, Type, } from './builders/browser/schema'; +export { buildWebpackBrowser as executeBrowserBuilder, BrowserBuilderOutput, } from './builders/browser'; +export { executeDevServerBuilder, DevServerBuilderOptions, DevServerBuilderOutput, } from './builders/dev-server'; +export { execute as executeExtractI18nBuilder, ExtractI18nBuilderOptions, } from './builders/extract-i18n'; +export { execute as executeKarmaBuilder, KarmaBuilderOptions, KarmaConfigOptions, } from './builders/karma'; +export { execute as executeProtractorBuilder, ProtractorBuilderOptions, } from './builders/protractor'; +export { execute as executeServerBuilder, ServerBuilderOptions, ServerBuilderOutput, } from './builders/server'; +export { execute as executeNgPackagrBuilder, NgPackagrBuilderOptions } from './builders/ng-packagr'; diff --git a/artifacts/build-angular/src/index.js b/artifacts/build-angular/src/index.js new file mode 100644 index 00000000..b72d6a7b --- /dev/null +++ b/artifacts/build-angular/src/index.js @@ -0,0 +1,44 @@ +"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 __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.executeNgPackagrBuilder = exports.executeServerBuilder = exports.executeProtractorBuilder = exports.executeKarmaBuilder = exports.executeExtractI18nBuilder = exports.executeDevServerBuilder = exports.executeBrowserBuilder = exports.Type = exports.OutputHashing = exports.CrossOrigin = void 0; +__exportStar(require("./transforms"), exports); +var schema_1 = require("./builders/browser/schema"); +Object.defineProperty(exports, "CrossOrigin", { enumerable: true, get: function () { return schema_1.CrossOrigin; } }); +Object.defineProperty(exports, "OutputHashing", { enumerable: true, get: function () { return schema_1.OutputHashing; } }); +Object.defineProperty(exports, "Type", { enumerable: true, get: function () { return schema_1.Type; } }); +var browser_1 = require("./builders/browser"); +Object.defineProperty(exports, "executeBrowserBuilder", { enumerable: true, get: function () { return browser_1.buildWebpackBrowser; } }); +var dev_server_1 = require("./builders/dev-server"); +Object.defineProperty(exports, "executeDevServerBuilder", { enumerable: true, get: function () { return dev_server_1.executeDevServerBuilder; } }); +var extract_i18n_1 = require("./builders/extract-i18n"); +Object.defineProperty(exports, "executeExtractI18nBuilder", { enumerable: true, get: function () { return extract_i18n_1.execute; } }); +var karma_1 = require("./builders/karma"); +Object.defineProperty(exports, "executeKarmaBuilder", { enumerable: true, get: function () { return karma_1.execute; } }); +var protractor_1 = require("./builders/protractor"); +Object.defineProperty(exports, "executeProtractorBuilder", { enumerable: true, get: function () { return protractor_1.execute; } }); +var server_1 = require("./builders/server"); +Object.defineProperty(exports, "executeServerBuilder", { enumerable: true, get: function () { return server_1.execute; } }); +var ng_packagr_1 = require("./builders/ng-packagr"); +Object.defineProperty(exports, "executeNgPackagrBuilder", { enumerable: true, get: function () { return ng_packagr_1.execute; } }); +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/sass/rebasing-importer.d.ts b/artifacts/build-angular/src/sass/rebasing-importer.d.ts new file mode 100644 index 00000000..45059359 --- /dev/null +++ b/artifacts/build-angular/src/sass/rebasing-importer.d.ts @@ -0,0 +1,103 @@ +/** + * @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 { RawSourceMap } from '@ampproject/remapping'; +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; + directories: Set; +} +/** + * 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 + * reflect the final filesystem location of the output CSS file. + * + * This class provides the core of the rebasing functionality. To ensure that each file is processed + * by this importer's load implementation, the Sass compiler requires the importer's canonicalize + * function to return a non-null value with the resolved location of the requested stylesheet. + * Concrete implementations of this class must provide this canonicalize functionality for rebasing + * to be effective. + */ +declare abstract class UrlRebasingImporter implements Importer<'sync'> { + private entryDirectory; + private rebaseSourceMaps?; + /** + * @param entryDirectory The directory of the entry stylesheet that was passed to the Sass compiler. + * @param rebaseSourceMaps When provided, rebased files will have an intermediate sourcemap added to the Map + * which can be used to generate a final sourcemap that contains original sources. + */ + constructor(entryDirectory: string, rebaseSourceMaps?: Map | undefined); + abstract canonicalize(url: string, options: { + fromImport: boolean; + }): URL | null; + load(canonicalUrl: URL): ImporterResult | null; +} +/** + * Provides the Sass importer logic to resolve relative stylesheet imports via both import and use rules + * and also rebase any `url()` function usage within those stylesheets. The rebasing will ensure that + * the URLs in the output of the Sass compiler reflect the final filesystem location of the output CSS file. + */ +export declare class RelativeUrlRebasingImporter extends UrlRebasingImporter { + private directoryCache; + constructor(entryDirectory: string, directoryCache?: Map, rebaseSourceMaps?: Map); + canonicalize(url: string, options: { + fromImport: boolean; + }): URL | null; + /** + * Attempts to resolve a provided URL to a stylesheet file using the Sass compiler's resolution algorithm. + * Based on https://github.com/sass/dart-sass/blob/44d6bb6ac72fe6b93f5bfec371a1fffb18e6b76d/lib/src/importer/utils.dart + * @param url The file protocol URL to resolve. + * @param fromImport If true, URL was from an import rule; otherwise from a use rule. + * @param checkDirectory If true, try checking for a directory with the base name containing an index file. + * @returns A full resolved URL of the stylesheet file or `null` if not found. + */ + private resolveImport; + /** + * 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 path for a stylesheet file or `null` if not found. + * @throws If there are ambiguous files discovered. + */ + private checkFound; +} +/** + * Provides the Sass importer logic to resolve module (npm package) stylesheet imports via both import and + * use rules and also rebase any `url()` function usage within those stylesheets. The rebasing will ensure that + * the URLs in the output of the Sass compiler reflect the final filesystem location of the output CSS file. + */ +export declare class ModuleUrlRebasingImporter extends RelativeUrlRebasingImporter { + private finder; + constructor(entryDirectory: string, directoryCache: Map, rebaseSourceMaps: Map | undefined, finder: FileImporter<'sync'>['findFileUrl']); + canonicalize(url: string, options: { + fromImport: boolean; + }): URL | null; +} +/** + * Provides the Sass importer logic to resolve load paths located stylesheet imports via both import and + * use rules and also rebase any `url()` function usage within those stylesheets. The rebasing will ensure that + * the URLs in the output of the Sass compiler reflect the final filesystem location of the output CSS file. + */ +export declare class LoadPathsUrlRebasingImporter extends RelativeUrlRebasingImporter { + private loadPaths; + constructor(entryDirectory: string, directoryCache: Map, rebaseSourceMaps: Map | undefined, loadPaths: Iterable); + canonicalize(url: string, options: { + fromImport: boolean; + }): URL | null; +} +/** + * Workaround for Sass not calling instance methods with `this`. + * The `canonicalize` and `load` methods will be bound to the class instance. + * @param importer A Sass importer to bind. + * @returns The bound Sass importer. + */ +export declare function sassBindWorkaround(importer: T): T; +export {}; diff --git a/artifacts/build-angular/src/sass/rebasing-importer.js b/artifacts/build-angular/src/sass/rebasing-importer.js new file mode 100644 index 00000000..26c92244 --- /dev/null +++ b/artifacts/build-angular/src/sass/rebasing-importer.js @@ -0,0 +1,445 @@ +"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 __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.sassBindWorkaround = exports.LoadPathsUrlRebasingImporter = exports.ModuleUrlRebasingImporter = exports.RelativeUrlRebasingImporter = void 0; +const magic_string_1 = __importDefault(require("magic-string")); +const node_fs_1 = require("node:fs"); +const node_path_1 = require("node:path"); +const node_url_1 = require("node:url"); +/** + * 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 + * reflect the final filesystem location of the output CSS file. + * + * This class provides the core of the rebasing functionality. To ensure that each file is processed + * by this importer's load implementation, the Sass compiler requires the importer's canonicalize + * function to return a non-null value with the resolved location of the requested stylesheet. + * Concrete implementations of this class must provide this canonicalize functionality for rebasing + * to be effective. + */ +class UrlRebasingImporter { + /** + * @param entryDirectory The directory of the entry stylesheet that was passed to the Sass compiler. + * @param rebaseSourceMaps When provided, rebased files will have an intermediate sourcemap added to the Map + * which can be used to generate a final sourcemap that contains original sources. + */ + constructor(entryDirectory, rebaseSourceMaps) { + this.entryDirectory = entryDirectory; + this.rebaseSourceMaps = rebaseSourceMaps; + } + load(canonicalUrl) { + const stylesheetPath = (0, node_url_1.fileURLToPath)(canonicalUrl); + const stylesheetDirectory = (0, node_path_1.dirname)(stylesheetPath); + let contents = (0, node_fs_1.readFileSync)(stylesheetPath, 'utf-8'); + // Rebase any URLs that are found + let updatedContents; + for (const { start, end, value } of findUrls(contents)) { + // Skip if value is empty or a Sass variable + if (value.length === 0 || value.startsWith('$')) { + continue; + } + // Skip if root-relative, absolute or protocol relative url + if (/^((?:\w+:)?\/\/|data:|chrome:|#|\/)/.test(value)) { + continue; + } + const rebasedPath = (0, node_path_1.relative)(this.entryDirectory, (0, node_path_1.join)(stylesheetDirectory, value)); + // Normalize path separators and escape characters + // https://developer.mozilla.org/en-US/docs/Web/CSS/url#syntax + const rebasedUrl = './' + rebasedPath.replace(/\\/g, '/').replace(/[()\s'"]/g, '\\$&'); + updatedContents ?? (updatedContents = new magic_string_1.default(contents)); + updatedContents.update(start, end, rebasedUrl); + } + if (updatedContents) { + contents = updatedContents.toString(); + if (this.rebaseSourceMaps) { + // Generate an intermediate source map for the rebasing changes + const map = updatedContents.generateMap({ + hires: true, + includeContent: true, + source: canonicalUrl.href, + }); + this.rebaseSourceMaps.set(canonicalUrl.href, map); + } + } + let syntax; + switch ((0, node_path_1.extname)(stylesheetPath).toLowerCase()) { + case 'css': + syntax = 'css'; + break; + case 'sass': + syntax = 'indented'; + break; + default: + syntax = 'scss'; + break; + } + return { + contents, + syntax, + sourceMapUrl: canonicalUrl, + }; + } +} +/** + * Determines if a unicode code point is a CSS whitespace character. + * @param code The unicode code point to test. + * @returns true, if the code point is CSS whitespace; false, otherwise. + */ +function isWhitespace(code) { + // Based on https://www.w3.org/TR/css-syntax-3/#whitespace + switch (code) { + case 0x0009: // tab + case 0x0020: // space + case 0x000a: // line feed + case 0x000c: // form feed + case 0x000d: // carriage return + return true; + default: + return false; + } +} +/** + * Scans a CSS or Sass file and locates all valid url function values as defined by the CSS + * syntax specification. + * @param contents A string containing a CSS or Sass file to scan. + * @returns An iterable that yields each CSS url function value found. + */ +function* findUrls(contents) { + let pos = 0; + let width = 1; + let current = -1; + const next = () => { + pos += width; + current = contents.codePointAt(pos) ?? -1; + width = current > 0xffff ? 2 : 1; + return current; + }; + // Based on https://www.w3.org/TR/css-syntax-3/#consume-ident-like-token + while ((pos = contents.indexOf('url(', pos)) !== -1) { + // Set to position of the ( + pos += 3; + width = 1; + // Consume all leading whitespace + while (isWhitespace(next())) { + /* empty */ + } + // Initialize URL state + const url = { start: pos, end: -1, value: '' }; + let complete = false; + // If " or ', then consume the value as a string + if (current === 0x0022 || current === 0x0027) { + const ending = current; + // Based on https://www.w3.org/TR/css-syntax-3/#consume-string-token + while (!complete) { + switch (next()) { + case -1: // EOF + return; + case 0x000a: // line feed + case 0x000c: // form feed + case 0x000d: // carriage return + // Invalid + complete = true; + break; + case 0x005c: // \ -- character escape + // If not EOF or newline, add the character after the escape + switch (next()) { + case -1: + return; + case 0x000a: // line feed + case 0x000c: // form feed + case 0x000d: // carriage return + // Skip when inside a string + break; + default: + // TODO: Handle hex escape codes + url.value += String.fromCodePoint(current); + break; + } + break; + case ending: + // Full string position should include the quotes for replacement + url.end = pos + 1; + complete = true; + yield url; + break; + default: + url.value += String.fromCodePoint(current); + break; + } + } + next(); + continue; + } + // Based on https://www.w3.org/TR/css-syntax-3/#consume-url-token + while (!complete) { + switch (current) { + case -1: // EOF + return; + case 0x0022: // " + case 0x0027: // ' + case 0x0028: // ( + // Invalid + complete = true; + break; + case 0x0029: // ) + // URL is valid and complete + url.end = pos; + complete = true; + break; + case 0x005c: // \ -- character escape + // If not EOF or newline, add the character after the escape + switch (next()) { + case -1: // EOF + return; + case 0x000a: // line feed + case 0x000c: // form feed + case 0x000d: // carriage return + // Invalid + complete = true; + break; + default: + // TODO: Handle hex escape codes + url.value += String.fromCodePoint(current); + break; + } + break; + default: + if (isWhitespace(current)) { + while (isWhitespace(next())) { + /* empty */ + } + // Unescaped whitespace is only valid before the closing ) + if (current === 0x0029) { + // URL is valid + url.end = pos; + } + complete = true; + } + else { + // Add the character to the url value + url.value += String.fromCodePoint(current); + } + break; + } + next(); + } + // An end position indicates a URL was found + if (url.end !== -1) { + yield url; + } + } +} +/** + * Provides the Sass importer logic to resolve relative stylesheet imports via both import and use rules + * and also rebase any `url()` function usage within those stylesheets. The rebasing will ensure that + * the URLs in the output of the Sass compiler reflect the final filesystem location of the output CSS file. + */ +class RelativeUrlRebasingImporter extends UrlRebasingImporter { + constructor(entryDirectory, directoryCache = new Map(), rebaseSourceMaps) { + super(entryDirectory, rebaseSourceMaps); + this.directoryCache = directoryCache; + } + canonicalize(url, options) { + return this.resolveImport(url, options.fromImport, true); + } + /** + * Attempts to resolve a provided URL to a stylesheet file using the Sass compiler's resolution algorithm. + * Based on https://github.com/sass/dart-sass/blob/44d6bb6ac72fe6b93f5bfec371a1fffb18e6b76d/lib/src/importer/utils.dart + * @param url The file protocol URL to resolve. + * @param fromImport If true, URL was from an import rule; otherwise from a use rule. + * @param checkDirectory If true, try checking for a directory with the base name containing an index file. + * @returns A full resolved URL of the stylesheet file or `null` if not found. + */ + resolveImport(url, fromImport, checkDirectory) { + let stylesheetPath; + try { + stylesheetPath = (0, node_url_1.fileURLToPath)(url); + } + catch { + // Only file protocol URLs are supported by this importer + return null; + } + const directory = (0, node_path_1.dirname)(stylesheetPath); + const extension = (0, node_path_1.extname)(stylesheetPath); + 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); + const importPotentials = new Set(); + const defaultPotentials = new Set(); + if (hasStyleExtension) { + if (fromImport) { + importPotentials.add(filename + '.import' + extension); + importPotentials.add('_' + filename + '.import' + extension); + } + defaultPotentials.add(filename + extension); + defaultPotentials.add('_' + filename + extension); + } + else { + if (fromImport) { + importPotentials.add(filename + '.import.scss'); + importPotentials.add(filename + '.import.sass'); + importPotentials.add(filename + '.import.css'); + importPotentials.add('_' + filename + '.import.scss'); + importPotentials.add('_' + filename + '.import.sass'); + importPotentials.add('_' + filename + '.import.css'); + } + defaultPotentials.add(filename + '.scss'); + defaultPotentials.add(filename + '.sass'); + defaultPotentials.add(filename + '.css'); + defaultPotentials.add('_' + filename + '.scss'); + defaultPotentials.add('_' + filename + '.sass'); + defaultPotentials.add('_' + filename + '.css'); + } + let foundDefaults; + let foundImports; + let hasPotentialIndex = false; + 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 }); + } + catch { + return null; + } + 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 = this.checkFound(foundImports) ?? this.checkFound(foundDefaults); + 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 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 path for a stylesheet file or `null` if not found. + * @throws If there are ambiguous files discovered. + */ + checkFound(found) { + if (found.length === 0) { + // Not found + return null; + } + // More than one found file may be an error + if (found.length > 1) { + // Presence of CSS files alongside a Sass file does not cause an error + const foundWithoutCss = found.filter((element) => (0, node_path_1.extname)(element) !== '.css'); + // If the length is zero then there are two or more css files + // If the length is more than one than there are two or more sass/scss files + if (foundWithoutCss.length !== 1) { + throw new Error('Ambiguous import detected.'); + } + // 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 foundWithoutCss[0]; + } + return found[0]; + } +} +exports.RelativeUrlRebasingImporter = RelativeUrlRebasingImporter; +/** + * Provides the Sass importer logic to resolve module (npm package) stylesheet imports via both import and + * use rules and also rebase any `url()` function usage within those stylesheets. The rebasing will ensure that + * the URLs in the output of the Sass compiler reflect the final filesystem location of the output CSS file. + */ +class ModuleUrlRebasingImporter extends RelativeUrlRebasingImporter { + constructor(entryDirectory, directoryCache, rebaseSourceMaps, finder) { + super(entryDirectory, directoryCache, rebaseSourceMaps); + this.finder = finder; + } + canonicalize(url, options) { + if (url.startsWith('file://')) { + return super.canonicalize(url, options); + } + const result = this.finder(url, options); + return result ? super.canonicalize(result.href, options) : null; + } +} +exports.ModuleUrlRebasingImporter = ModuleUrlRebasingImporter; +/** + * Provides the Sass importer logic to resolve load paths located stylesheet imports via both import and + * use rules and also rebase any `url()` function usage within those stylesheets. The rebasing will ensure that + * the URLs in the output of the Sass compiler reflect the final filesystem location of the output CSS file. + */ +class LoadPathsUrlRebasingImporter extends RelativeUrlRebasingImporter { + constructor(entryDirectory, directoryCache, rebaseSourceMaps, loadPaths) { + super(entryDirectory, directoryCache, rebaseSourceMaps); + this.loadPaths = loadPaths; + } + canonicalize(url, options) { + if (url.startsWith('file://')) { + return super.canonicalize(url, options); + } + let result = null; + for (const loadPath of this.loadPaths) { + result = super.canonicalize((0, node_url_1.pathToFileURL)((0, node_path_1.join)(loadPath, url)).href, options); + if (result !== null) { + break; + } + } + return result; + } +} +exports.LoadPathsUrlRebasingImporter = LoadPathsUrlRebasingImporter; +/** + * Workaround for Sass not calling instance methods with `this`. + * The `canonicalize` and `load` methods will be bound to the class instance. + * @param importer A Sass importer to bind. + * @returns The bound Sass importer. + */ +function sassBindWorkaround(importer) { + importer.canonicalize = importer.canonicalize.bind(importer); + importer.load = importer.load.bind(importer); + return importer; +} +exports.sassBindWorkaround = sassBindWorkaround; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rebasing-importer.js","sourceRoot":"","sources":["../../../../../../../../packages/angular_devkit/build_angular/src/sass/rebasing-importer.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 { RawSourceMap } from '@ampproject/remapping';\nimport MagicString from 'magic-string';\nimport { readFileSync, readdirSync } from 'node:fs';\nimport { basename, dirname, extname, join, relative } from 'node:path';\nimport { fileURLToPath, pathToFileURL } from 'node:url';\nimport type { FileImporter, Importer, ImporterResult, Syntax } from 'sass';\n\n/**\n * A preprocessed cache entry for the files and directories within a previously searched\n * directory when performing Sass import resolution.\n */\nexport interface DirectoryEntry {\n  files: Set<string>;\n  directories: Set<string>;\n}\n\n/**\n * A Sass Importer base class that provides the load logic to rebase all `url()` functions\n * within a stylesheet. The rebasing will ensure that the URLs in the output of the Sass compiler\n * reflect the final filesystem location of the output CSS file.\n *\n * This class provides the core of the rebasing functionality. To ensure that each file is processed\n * by this importer's load implementation, the Sass compiler requires the importer's canonicalize\n * function to return a non-null value with the resolved location of the requested stylesheet.\n * Concrete implementations of this class must provide this canonicalize functionality for rebasing\n * to be effective.\n */\nabstract class UrlRebasingImporter implements Importer<'sync'> {\n  /**\n   * @param entryDirectory The directory of the entry stylesheet that was passed to the Sass compiler.\n   * @param rebaseSourceMaps When provided, rebased files will have an intermediate sourcemap added to the Map\n   * which can be used to generate a final sourcemap that contains original sources.\n   */\n  constructor(\n    private entryDirectory: string,\n    private rebaseSourceMaps?: Map<string, RawSourceMap>,\n  ) {}\n\n  abstract canonicalize(url: string, options: { fromImport: boolean }): URL | null;\n\n  load(canonicalUrl: URL): ImporterResult | null {\n    const stylesheetPath = fileURLToPath(canonicalUrl);\n    const stylesheetDirectory = dirname(stylesheetPath);\n    let contents = readFileSync(stylesheetPath, 'utf-8');\n\n    // Rebase any URLs that are found\n    let updatedContents;\n    for (const { start, end, value } of findUrls(contents)) {\n      // Skip if value is empty or a Sass variable\n      if (value.length === 0 || value.startsWith('$')) {\n        continue;\n      }\n\n      // Skip if root-relative, absolute or protocol relative url\n      if (/^((?:\\w+:)?\\/\\/|data:|chrome:|#|\\/)/.test(value)) {\n        continue;\n      }\n\n      const rebasedPath = relative(this.entryDirectory, join(stylesheetDirectory, value));\n\n      // Normalize path separators and escape characters\n      // https://developer.mozilla.org/en-US/docs/Web/CSS/url#syntax\n      const rebasedUrl = './' + rebasedPath.replace(/\\\\/g, '/').replace(/[()\\s'\"]/g, '\\\\$&');\n\n      updatedContents ??= new MagicString(contents);\n      updatedContents.update(start, end, rebasedUrl);\n    }\n\n    if (updatedContents) {\n      contents = updatedContents.toString();\n      if (this.rebaseSourceMaps) {\n        // Generate an intermediate source map for the rebasing changes\n        const map = updatedContents.generateMap({\n          hires: true,\n          includeContent: true,\n          source: canonicalUrl.href,\n        });\n        this.rebaseSourceMaps.set(canonicalUrl.href, map as RawSourceMap);\n      }\n    }\n\n    let syntax: Syntax | undefined;\n    switch (extname(stylesheetPath).toLowerCase()) {\n      case 'css':\n        syntax = 'css';\n        break;\n      case 'sass':\n        syntax = 'indented';\n        break;\n      default:\n        syntax = 'scss';\n        break;\n    }\n\n    return {\n      contents,\n      syntax,\n      sourceMapUrl: canonicalUrl,\n    };\n  }\n}\n\n/**\n * Determines if a unicode code point is a CSS whitespace character.\n * @param code The unicode code point to test.\n * @returns true, if the code point is CSS whitespace; false, otherwise.\n */\nfunction isWhitespace(code: number): boolean {\n  // Based on https://www.w3.org/TR/css-syntax-3/#whitespace\n  switch (code) {\n    case 0x0009: // tab\n    case 0x0020: // space\n    case 0x000a: // line feed\n    case 0x000c: // form feed\n    case 0x000d: // carriage return\n      return true;\n    default:\n      return false;\n  }\n}\n\n/**\n * Scans a CSS or Sass file and locates all valid url function values as defined by the CSS\n * syntax specification.\n * @param contents A string containing a CSS or Sass file to scan.\n * @returns An iterable that yields each CSS url function value found.\n */\nfunction* findUrls(contents: string): Iterable<{ start: number; end: number; value: string }> {\n  let pos = 0;\n  let width = 1;\n  let current = -1;\n  const next = () => {\n    pos += width;\n    current = contents.codePointAt(pos) ?? -1;\n    width = current > 0xffff ? 2 : 1;\n\n    return current;\n  };\n\n  // Based on https://www.w3.org/TR/css-syntax-3/#consume-ident-like-token\n  while ((pos = contents.indexOf('url(', pos)) !== -1) {\n    // Set to position of the (\n    pos += 3;\n    width = 1;\n\n    // Consume all leading whitespace\n    while (isWhitespace(next())) {\n      /* empty */\n    }\n\n    // Initialize URL state\n    const url = { start: pos, end: -1, value: '' };\n    let complete = false;\n\n    // If \" or ', then consume the value as a string\n    if (current === 0x0022 || current === 0x0027) {\n      const ending = current;\n      // Based on https://www.w3.org/TR/css-syntax-3/#consume-string-token\n      while (!complete) {\n        switch (next()) {\n          case -1: // EOF\n            return;\n          case 0x000a: // line feed\n          case 0x000c: // form feed\n          case 0x000d: // carriage return\n            // Invalid\n            complete = true;\n            break;\n          case 0x005c: // \\ -- character escape\n            // If not EOF or newline, add the character after the escape\n            switch (next()) {\n              case -1:\n                return;\n              case 0x000a: // line feed\n              case 0x000c: // form feed\n              case 0x000d: // carriage return\n                // Skip when inside a string\n                break;\n              default:\n                // TODO: Handle hex escape codes\n                url.value += String.fromCodePoint(current);\n                break;\n            }\n            break;\n          case ending:\n            // Full string position should include the quotes for replacement\n            url.end = pos + 1;\n            complete = true;\n            yield url;\n            break;\n          default:\n            url.value += String.fromCodePoint(current);\n            break;\n        }\n      }\n\n      next();\n      continue;\n    }\n\n    // Based on https://www.w3.org/TR/css-syntax-3/#consume-url-token\n    while (!complete) {\n      switch (current) {\n        case -1: // EOF\n          return;\n        case 0x0022: // \"\n        case 0x0027: // '\n        case 0x0028: // (\n          // Invalid\n          complete = true;\n          break;\n        case 0x0029: // )\n          // URL is valid and complete\n          url.end = pos;\n          complete = true;\n          break;\n        case 0x005c: // \\ -- character escape\n          // If not EOF or newline, add the character after the escape\n          switch (next()) {\n            case -1: // EOF\n              return;\n            case 0x000a: // line feed\n            case 0x000c: // form feed\n            case 0x000d: // carriage return\n              // Invalid\n              complete = true;\n              break;\n            default:\n              // TODO: Handle hex escape codes\n              url.value += String.fromCodePoint(current);\n              break;\n          }\n          break;\n        default:\n          if (isWhitespace(current)) {\n            while (isWhitespace(next())) {\n              /* empty */\n            }\n            // Unescaped whitespace is only valid before the closing )\n            if (current === 0x0029) {\n              // URL is valid\n              url.end = pos;\n            }\n            complete = true;\n          } else {\n            // Add the character to the url value\n            url.value += String.fromCodePoint(current);\n          }\n          break;\n      }\n      next();\n    }\n\n    // An end position indicates a URL was found\n    if (url.end !== -1) {\n      yield url;\n    }\n  }\n}\n\n/**\n * Provides the Sass importer logic to resolve relative stylesheet imports via both import and use rules\n * and also rebase any `url()` function usage within those stylesheets. The rebasing will ensure that\n * the URLs in the output of the Sass compiler reflect the final filesystem location of the output CSS file.\n */\nexport class RelativeUrlRebasingImporter extends UrlRebasingImporter {\n  constructor(\n    entryDirectory: string,\n    private directoryCache = new Map<string, DirectoryEntry>(),\n    rebaseSourceMaps?: Map<string, RawSourceMap>,\n  ) {\n    super(entryDirectory, rebaseSourceMaps);\n  }\n\n  canonicalize(url: string, options: { fromImport: boolean }): URL | null {\n    return this.resolveImport(url, options.fromImport, true);\n  }\n\n  /**\n   * Attempts to resolve a provided URL to a stylesheet file using the Sass compiler's resolution algorithm.\n   * Based on https://github.com/sass/dart-sass/blob/44d6bb6ac72fe6b93f5bfec371a1fffb18e6b76d/lib/src/importer/utils.dart\n   * @param url The file protocol URL to resolve.\n   * @param fromImport If true, URL was from an import rule; otherwise from a use rule.\n   * @param checkDirectory If true, try checking for a directory with the base name containing an index file.\n   * @returns A full resolved URL of the stylesheet file or `null` if not found.\n   */\n  private resolveImport(url: string, fromImport: boolean, checkDirectory: boolean): URL | null {\n    let stylesheetPath;\n    try {\n      stylesheetPath = fileURLToPath(url);\n    } catch {\n      // Only file protocol URLs are supported by this importer\n      return null;\n    }\n\n    const directory = dirname(stylesheetPath);\n    const extension = extname(stylesheetPath);\n    const hasStyleExtension =\n      extension === '.scss' || extension === '.sass' || extension === '.css';\n    // Remove the style extension if present to allow adding the `.import` suffix\n    const filename = basename(stylesheetPath, hasStyleExtension ? extension : undefined);\n\n    const importPotentials = new Set<string>();\n    const defaultPotentials = new Set<string>();\n\n    if (hasStyleExtension) {\n      if (fromImport) {\n        importPotentials.add(filename + '.import' + extension);\n        importPotentials.add('_' + filename + '.import' + extension);\n      }\n      defaultPotentials.add(filename + extension);\n      defaultPotentials.add('_' + filename + extension);\n    } else {\n      if (fromImport) {\n        importPotentials.add(filename + '.import.scss');\n        importPotentials.add(filename + '.import.sass');\n        importPotentials.add(filename + '.import.css');\n        importPotentials.add('_' + filename + '.import.scss');\n        importPotentials.add('_' + filename + '.import.sass');\n        importPotentials.add('_' + filename + '.import.css');\n      }\n      defaultPotentials.add(filename + '.scss');\n      defaultPotentials.add(filename + '.sass');\n      defaultPotentials.add(filename + '.css');\n      defaultPotentials.add('_' + filename + '.scss');\n      defaultPotentials.add('_' + filename + '.sass');\n      defaultPotentials.add('_' + filename + '.css');\n    }\n\n    let foundDefaults;\n    let foundImports;\n    let hasPotentialIndex = false;\n\n    let cachedEntries = this.directoryCache.get(directory);\n    if (cachedEntries) {\n      // If there is a preprocessed cache of the directory, perform an intersection of the potentials\n      // and the directory files.\n      const { files, directories } = cachedEntries;\n      foundDefaults = [...defaultPotentials].filter((potential) => files.has(potential));\n      foundImports = [...importPotentials].filter((potential) => files.has(potential));\n      hasPotentialIndex = checkDirectory && !hasStyleExtension && directories.has(filename);\n    } else {\n      // If no preprocessed cache exists, get the entries from the file system and, while searching,\n      // generate the cache for later requests.\n      let entries;\n      try {\n        entries = readdirSync(directory, { withFileTypes: true });\n      } catch {\n        return null;\n      }\n\n      foundDefaults = [];\n      foundImports = [];\n      cachedEntries = { files: new Set<string>(), directories: new Set<string>() };\n      for (const entry of entries) {\n        const isDirectory = entry.isDirectory();\n        if (isDirectory) {\n          cachedEntries.directories.add(entry.name);\n        }\n\n        // Record if the name should be checked as a directory with an index file\n        if (checkDirectory && !hasStyleExtension && entry.name === filename && isDirectory) {\n          hasPotentialIndex = true;\n        }\n\n        if (!entry.isFile()) {\n          continue;\n        }\n\n        cachedEntries.files.add(entry.name);\n\n        if (importPotentials.has(entry.name)) {\n          foundImports.push(entry.name);\n        }\n\n        if (defaultPotentials.has(entry.name)) {\n          foundDefaults.push(entry.name);\n        }\n      }\n\n      this.directoryCache.set(directory, cachedEntries);\n    }\n\n    // `foundImports` will only contain elements if `options.fromImport` is true\n    const result = this.checkFound(foundImports) ?? this.checkFound(foundDefaults);\n    if (result !== null) {\n      return pathToFileURL(join(directory, result));\n    }\n\n    if (hasPotentialIndex) {\n      // Check for index files using filename as a directory\n      return this.resolveImport(url + '/index', fromImport, false);\n    }\n\n    return null;\n  }\n\n  /**\n   * Checks an array of potential stylesheet files to determine if there is a valid\n   * stylesheet file. More than one discovered file may indicate an error.\n   * @param found An array of discovered stylesheet files.\n   * @returns A fully resolved path for a stylesheet file or `null` if not found.\n   * @throws If there are ambiguous files discovered.\n   */\n  private checkFound(found: string[]): string | null {\n    if (found.length === 0) {\n      // Not found\n      return null;\n    }\n\n    // More than one found file may be an error\n    if (found.length > 1) {\n      // Presence of CSS files alongside a Sass file does not cause an error\n      const foundWithoutCss = found.filter((element) => extname(element) !== '.css');\n      // If the length is zero then there are two or more css files\n      // If the length is more than one than there are two or more sass/scss files\n      if (foundWithoutCss.length !== 1) {\n        throw new Error('Ambiguous import detected.');\n      }\n\n      // Return the non-CSS file (sass/scss files have priority)\n      // https://github.com/sass/dart-sass/blob/44d6bb6ac72fe6b93f5bfec371a1fffb18e6b76d/lib/src/importer/utils.dart#L44-L47\n      return foundWithoutCss[0];\n    }\n\n    return found[0];\n  }\n}\n\n/**\n * Provides the Sass importer logic to resolve module (npm package) stylesheet imports via both import and\n * use rules and also rebase any `url()` function usage within those stylesheets. The rebasing will ensure that\n * the URLs in the output of the Sass compiler reflect the final filesystem location of the output CSS file.\n */\nexport class ModuleUrlRebasingImporter extends RelativeUrlRebasingImporter {\n  constructor(\n    entryDirectory: string,\n    directoryCache: Map<string, DirectoryEntry>,\n    rebaseSourceMaps: Map<string, RawSourceMap> | undefined,\n    private finder: FileImporter<'sync'>['findFileUrl'],\n  ) {\n    super(entryDirectory, directoryCache, rebaseSourceMaps);\n  }\n\n  override canonicalize(url: string, options: { fromImport: boolean }): URL | null {\n    if (url.startsWith('file://')) {\n      return super.canonicalize(url, options);\n    }\n\n    const result = this.finder(url, options);\n\n    return result ? super.canonicalize(result.href, options) : null;\n  }\n}\n\n/**\n * Provides the Sass importer logic to resolve load paths located stylesheet imports via both import and\n * use rules and also rebase any `url()` function usage within those stylesheets. The rebasing will ensure that\n * the URLs in the output of the Sass compiler reflect the final filesystem location of the output CSS file.\n */\nexport class LoadPathsUrlRebasingImporter extends RelativeUrlRebasingImporter {\n  constructor(\n    entryDirectory: string,\n    directoryCache: Map<string, DirectoryEntry>,\n    rebaseSourceMaps: Map<string, RawSourceMap> | undefined,\n    private loadPaths: Iterable<string>,\n  ) {\n    super(entryDirectory, directoryCache, rebaseSourceMaps);\n  }\n\n  override canonicalize(url: string, options: { fromImport: boolean }): URL | null {\n    if (url.startsWith('file://')) {\n      return super.canonicalize(url, options);\n    }\n\n    let result = null;\n    for (const loadPath of this.loadPaths) {\n      result = super.canonicalize(pathToFileURL(join(loadPath, url)).href, options);\n      if (result !== null) {\n        break;\n      }\n    }\n\n    return result;\n  }\n}\n\n/**\n * Workaround for Sass not calling instance methods with `this`.\n * The `canonicalize` and `load` methods will be bound to the class instance.\n * @param importer A Sass importer to bind.\n * @returns The bound Sass importer.\n */\nexport function sassBindWorkaround<T extends Importer>(importer: T): T {\n  importer.canonicalize = importer.canonicalize.bind(importer);\n  importer.load = importer.load.bind(importer);\n\n  return importer;\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/sass/sass-service-legacy.d.ts b/artifacts/build-angular/src/sass/sass-service-legacy.d.ts new file mode 100644 index 00000000..08e722e4 --- /dev/null +++ b/artifacts/build-angular/src/sass/sass-service-legacy.d.ts @@ -0,0 +1,51 @@ +/** + * @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 { LegacyResult as CompileResult, LegacyException as Exception, LegacyOptions as Options } from 'sass'; +/** + * The callback type for the `dart-sass` asynchronous render function. + */ +type RenderCallback = (error?: Exception, result?: CompileResult) => void; +/** + * A Sass renderer implementation that provides an interface that can be used by Webpack's + * `sass-loader`. The implementation uses a Worker thread to perform the Sass rendering + * with the `dart-sass` package. The `dart-sass` synchronous render function is used within + * the worker which can be up to two times faster than the asynchronous variant. + */ +export declare class SassLegacyWorkerImplementation { + private readonly workers; + private readonly availableWorkers; + private readonly requests; + private readonly workerPath; + private idCounter; + private nextWorkerIndex; + /** + * Provides information about the Sass implementation. + * This mimics enough of the `dart-sass` value to be used with the `sass-loader`. + */ + get info(): string; + /** + * The synchronous render function is not used by the `sass-loader`. + */ + renderSync(): never; + /** + * Asynchronously request a Sass stylesheet to be renderered. + * + * @param options The `dart-sass` options to use when rendering the stylesheet. + * @param callback The function to execute when the rendering is complete. + */ + render(options: Options<'async'>, callback: RenderCallback): void; + /** + * Shutdown the Sass render worker. + * Executing this method will stop any pending render requests. + */ + close(): void; + private createWorker; + private processImporters; + private createRequest; +} +export {}; diff --git a/artifacts/build-angular/src/sass/sass-service-legacy.js b/artifacts/build-angular/src/sass/sass-service-legacy.js new file mode 100644 index 00000000..b835c567 --- /dev/null +++ b/artifacts/build-angular/src/sass/sass-service-legacy.js @@ -0,0 +1,176 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.SassLegacyWorkerImplementation = void 0; +const path_1 = require("path"); +const worker_threads_1 = require("worker_threads"); +const environment_options_1 = require("../utils/environment-options"); +/** + * The maximum number of Workers that will be created to execute render requests. + */ +const MAX_RENDER_WORKERS = environment_options_1.maxWorkers; +/** + * A Sass renderer implementation that provides an interface that can be used by Webpack's + * `sass-loader`. The implementation uses a Worker thread to perform the Sass rendering + * with the `dart-sass` package. The `dart-sass` synchronous render function is used within + * the worker which can be up to two times faster than the asynchronous variant. + */ +class SassLegacyWorkerImplementation { + constructor() { + this.workers = []; + this.availableWorkers = []; + this.requests = new Map(); + this.workerPath = (0, path_1.join)(__dirname, './worker-legacy.js'); + this.idCounter = 1; + this.nextWorkerIndex = 0; + } + /** + * Provides information about the Sass implementation. + * This mimics enough of the `dart-sass` value to be used with the `sass-loader`. + */ + get info() { + return 'dart-sass\tworker'; + } + /** + * The synchronous render function is not used by the `sass-loader`. + */ + renderSync() { + throw new Error('Sass renderSync is not supported.'); + } + /** + * Asynchronously request a Sass stylesheet to be renderered. + * + * @param options The `dart-sass` options to use when rendering the stylesheet. + * @param callback The function to execute when the rendering is complete. + */ + render(options, callback) { + // The `functions`, `logger` and `importer` options are JavaScript functions that cannot be transferred. + // If any additional function options are added in the future, they must be excluded as well. + const { functions, importer, logger, ...serializableOptions } = options; + // The CLI's configuration does not use or expose the ability to defined custom Sass functions + if (functions && Object.keys(functions).length > 0) { + throw new Error('Sass custom functions are not supported.'); + } + let workerIndex = this.availableWorkers.pop(); + if (workerIndex === undefined) { + if (this.workers.length < MAX_RENDER_WORKERS) { + workerIndex = this.workers.length; + this.workers.push(this.createWorker()); + } + else { + workerIndex = this.nextWorkerIndex++; + if (this.nextWorkerIndex >= this.workers.length) { + this.nextWorkerIndex = 0; + } + } + } + const request = this.createRequest(workerIndex, callback, importer); + this.requests.set(request.id, request); + this.workers[workerIndex].postMessage({ + id: request.id, + hasImporter: !!importer, + options: serializableOptions, + }); + } + /** + * Shutdown the Sass render worker. + * Executing this method will stop any pending render requests. + */ + close() { + for (const worker of this.workers) { + try { + void worker.terminate(); + } + catch { } + } + this.requests.clear(); + } + createWorker() { + const { port1: mainImporterPort, port2: workerImporterPort } = new worker_threads_1.MessageChannel(); + const importerSignal = new Int32Array(new SharedArrayBuffer(4)); + const worker = new worker_threads_1.Worker(this.workerPath, { + workerData: { workerImporterPort, importerSignal }, + transferList: [workerImporterPort], + }); + worker.on('message', (response) => { + const request = this.requests.get(response.id); + if (!request) { + return; + } + this.requests.delete(response.id); + this.availableWorkers.push(request.workerIndex); + if (response.result) { + // The results are expected to be Node.js `Buffer` objects but will each be transferred as + // a Uint8Array that does not have the expected `toString` behavior of a `Buffer`. + const { css, map, stats } = response.result; + const result = { + // This `Buffer.from` override will use the memory directly and avoid making a copy + css: Buffer.from(css.buffer, css.byteOffset, css.byteLength), + stats, + }; + if (map) { + // This `Buffer.from` override will use the memory directly and avoid making a copy + result.map = Buffer.from(map.buffer, map.byteOffset, map.byteLength); + } + request.callback(undefined, result); + } + else { + request.callback(response.error); + } + }); + mainImporterPort.on('message', ({ id, url, prev, fromImport, }) => { + const request = this.requests.get(id); + if (!request?.importers) { + mainImporterPort.postMessage(null); + Atomics.store(importerSignal, 0, 1); + Atomics.notify(importerSignal, 0); + return; + } + this.processImporters(request.importers, url, prev, fromImport) + .then((result) => { + mainImporterPort.postMessage(result); + }) + .catch((error) => { + mainImporterPort.postMessage(error); + }) + .finally(() => { + Atomics.store(importerSignal, 0, 1); + Atomics.notify(importerSignal, 0); + }); + }); + mainImporterPort.unref(); + return worker; + } + async processImporters(importers, url, prev, fromImport) { + let result = null; + for (const importer of importers) { + result = await new Promise((resolve) => { + // Importers can be both sync and async + const innerResult = importer.call({ fromImport }, url, prev, resolve); + if (innerResult !== undefined) { + resolve(innerResult); + } + }); + if (result) { + break; + } + } + return result; + } + createRequest(workerIndex, callback, importer) { + return { + id: this.idCounter++, + workerIndex, + callback, + importers: !importer || Array.isArray(importer) ? importer : [importer], + }; + } +} +exports.SassLegacyWorkerImplementation = SassLegacyWorkerImplementation; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sass-service-legacy.js","sourceRoot":"","sources":["../../../../../../../../packages/angular_devkit/build_angular/src/sass/sass-service-legacy.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 { join } from 'path';\nimport {\n  LegacyAsyncImporter as AsyncImporter,\n  LegacyResult as CompileResult,\n  LegacyException as Exception,\n  LegacyImporterResult as ImporterResult,\n  LegacyImporterThis as ImporterThis,\n  LegacyOptions as Options,\n  LegacySyncImporter as SyncImporter,\n} from 'sass';\nimport { MessageChannel, Worker } from 'worker_threads';\nimport { maxWorkers } from '../utils/environment-options';\n\n/**\n * The maximum number of Workers that will be created to execute render requests.\n */\nconst MAX_RENDER_WORKERS = maxWorkers;\n\n/**\n * The callback type for the `dart-sass` asynchronous render function.\n */\ntype RenderCallback = (error?: Exception, result?: CompileResult) => void;\n\n/**\n * An object containing the contextual information for a specific render request.\n */\ninterface RenderRequest {\n  id: number;\n  workerIndex: number;\n  callback: RenderCallback;\n  importers?: (SyncImporter | AsyncImporter)[];\n}\n\n/**\n * A response from the Sass render Worker containing the result of the operation.\n */\ninterface RenderResponseMessage {\n  id: number;\n  error?: Exception;\n  result?: CompileResult;\n}\n\n/**\n * A Sass renderer implementation that provides an interface that can be used by Webpack's\n * `sass-loader`. The implementation uses a Worker thread to perform the Sass rendering\n * with the `dart-sass` package.  The `dart-sass` synchronous render function is used within\n * the worker which can be up to two times faster than the asynchronous variant.\n */\nexport class SassLegacyWorkerImplementation {\n  private readonly workers: Worker[] = [];\n  private readonly availableWorkers: number[] = [];\n  private readonly requests = new Map<number, RenderRequest>();\n  private readonly workerPath = join(__dirname, './worker-legacy.js');\n  private idCounter = 1;\n  private nextWorkerIndex = 0;\n\n  /**\n   * Provides information about the Sass implementation.\n   * This mimics enough of the `dart-sass` value to be used with the `sass-loader`.\n   */\n  get info(): string {\n    return 'dart-sass\\tworker';\n  }\n\n  /**\n   * The synchronous render function is not used by the `sass-loader`.\n   */\n  renderSync(): never {\n    throw new Error('Sass renderSync is not supported.');\n  }\n\n  /**\n   * Asynchronously request a Sass stylesheet to be renderered.\n   *\n   * @param options The `dart-sass` options to use when rendering the stylesheet.\n   * @param callback The function to execute when the rendering is complete.\n   */\n  render(options: Options<'async'>, callback: RenderCallback): void {\n    // The `functions`, `logger` and `importer` options are JavaScript functions that cannot be transferred.\n    // If any additional function options are added in the future, they must be excluded as well.\n    const { functions, importer, logger, ...serializableOptions } = options;\n\n    // The CLI's configuration does not use or expose the ability to defined custom Sass functions\n    if (functions && Object.keys(functions).length > 0) {\n      throw new Error('Sass custom functions are not supported.');\n    }\n\n    let workerIndex = this.availableWorkers.pop();\n    if (workerIndex === undefined) {\n      if (this.workers.length < MAX_RENDER_WORKERS) {\n        workerIndex = this.workers.length;\n        this.workers.push(this.createWorker());\n      } else {\n        workerIndex = this.nextWorkerIndex++;\n        if (this.nextWorkerIndex >= this.workers.length) {\n          this.nextWorkerIndex = 0;\n        }\n      }\n    }\n\n    const request = this.createRequest(workerIndex, callback, importer);\n    this.requests.set(request.id, request);\n\n    this.workers[workerIndex].postMessage({\n      id: request.id,\n      hasImporter: !!importer,\n      options: serializableOptions,\n    });\n  }\n\n  /**\n   * Shutdown the Sass render worker.\n   * Executing this method will stop any pending render requests.\n   */\n  close(): void {\n    for (const worker of this.workers) {\n      try {\n        void worker.terminate();\n      } catch {}\n    }\n    this.requests.clear();\n  }\n\n  private createWorker(): Worker {\n    const { port1: mainImporterPort, port2: workerImporterPort } = new MessageChannel();\n    const importerSignal = new Int32Array(new SharedArrayBuffer(4));\n\n    const worker = new Worker(this.workerPath, {\n      workerData: { workerImporterPort, importerSignal },\n      transferList: [workerImporterPort],\n    });\n\n    worker.on('message', (response: RenderResponseMessage) => {\n      const request = this.requests.get(response.id);\n      if (!request) {\n        return;\n      }\n\n      this.requests.delete(response.id);\n      this.availableWorkers.push(request.workerIndex);\n\n      if (response.result) {\n        // The results are expected to be Node.js `Buffer` objects but will each be transferred as\n        // a Uint8Array that does not have the expected `toString` behavior of a `Buffer`.\n        const { css, map, stats } = response.result;\n        const result: CompileResult = {\n          // This `Buffer.from` override will use the memory directly and avoid making a copy\n          css: Buffer.from(css.buffer, css.byteOffset, css.byteLength),\n          stats,\n        };\n        if (map) {\n          // This `Buffer.from` override will use the memory directly and avoid making a copy\n          result.map = Buffer.from(map.buffer, map.byteOffset, map.byteLength);\n        }\n        request.callback(undefined, result);\n      } else {\n        request.callback(response.error);\n      }\n    });\n\n    mainImporterPort.on(\n      'message',\n      ({\n        id,\n        url,\n        prev,\n        fromImport,\n      }: {\n        id: number;\n        url: string;\n        prev: string;\n        fromImport: boolean;\n      }) => {\n        const request = this.requests.get(id);\n        if (!request?.importers) {\n          mainImporterPort.postMessage(null);\n          Atomics.store(importerSignal, 0, 1);\n          Atomics.notify(importerSignal, 0);\n\n          return;\n        }\n\n        this.processImporters(request.importers, url, prev, fromImport)\n          .then((result) => {\n            mainImporterPort.postMessage(result);\n          })\n          .catch((error) => {\n            mainImporterPort.postMessage(error);\n          })\n          .finally(() => {\n            Atomics.store(importerSignal, 0, 1);\n            Atomics.notify(importerSignal, 0);\n          });\n      },\n    );\n\n    mainImporterPort.unref();\n\n    return worker;\n  }\n\n  private async processImporters(\n    importers: Iterable<SyncImporter | AsyncImporter>,\n    url: string,\n    prev: string,\n    fromImport: boolean,\n  ): Promise<ImporterResult> {\n    let result = null;\n    for (const importer of importers) {\n      result = await new Promise<ImporterResult>((resolve) => {\n        // Importers can be both sync and async\n        const innerResult = (importer as AsyncImporter).call(\n          { fromImport } as ImporterThis,\n          url,\n          prev,\n          resolve,\n        );\n        if (innerResult !== undefined) {\n          resolve(innerResult);\n        }\n      });\n\n      if (result) {\n        break;\n      }\n    }\n\n    return result;\n  }\n\n  private createRequest(\n    workerIndex: number,\n    callback: RenderCallback,\n    importer: SyncImporter | AsyncImporter | (SyncImporter | AsyncImporter)[] | undefined,\n  ): RenderRequest {\n    return {\n      id: this.idCounter++,\n      workerIndex,\n      callback,\n      importers: !importer || Array.isArray(importer) ? importer : [importer],\n    };\n  }\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/sass/sass-service.d.ts b/artifacts/build-angular/src/sass/sass-service.d.ts new file mode 100644 index 00000000..9c8ffdd2 --- /dev/null +++ b/artifacts/build-angular/src/sass/sass-service.d.ts @@ -0,0 +1,60 @@ +/** + * @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 { CompileResult, FileImporter, StringOptionsWithImporter, StringOptionsWithoutImporter } from 'sass'; +type FileImporterOptions = Parameters[1]; +export interface FileImporterWithRequestContextOptions extends FileImporterOptions { + /** + * This is a custom option and is required as SASS does not provide context from which the file is being resolved. + * This breaks Yarn PNP as transitive deps cannot be resolved from the workspace root. + * + * Workaround until https://github.com/sass/sass/issues/3247 is addressed. + */ + previousResolvedModules?: Set; +} +/** + * A Sass renderer implementation that provides an interface that can be used by Webpack's + * `sass-loader`. The implementation uses a Worker thread to perform the Sass rendering + * with the `dart-sass` package. The `dart-sass` synchronous render function is used within + * the worker which can be up to two times faster than the asynchronous variant. + */ +export declare class SassWorkerImplementation { + private rebase; + private readonly workers; + private readonly availableWorkers; + private readonly requests; + private readonly workerPath; + private idCounter; + private nextWorkerIndex; + constructor(rebase?: boolean); + /** + * Provides information about the Sass implementation. + * This mimics enough of the `dart-sass` value to be used with the `sass-loader`. + */ + get info(): string; + /** + * The synchronous render function is not used by the `sass-loader`. + */ + compileString(): never; + /** + * Asynchronously request a Sass stylesheet to be renderered. + * + * @param source The contents to compile. + * @param options The `dart-sass` options to use when rendering the stylesheet. + */ + compileStringAsync(source: string, options: StringOptionsWithImporter<'async'> | StringOptionsWithoutImporter<'async'>): Promise; + /** + * Shutdown the Sass render worker. + * Executing this method will stop any pending render requests. + */ + close(): void; + private createWorker; + private processImporters; + private createRequest; + private isImporter; +} +export {}; diff --git a/artifacts/build-angular/src/sass/sass-service.js b/artifacts/build-angular/src/sass/sass-service.js new file mode 100644 index 00000000..e0bcb80e --- /dev/null +++ b/artifacts/build-angular/src/sass/sass-service.js @@ -0,0 +1,214 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.SassWorkerImplementation = void 0; +const node_path_1 = require("node:path"); +const node_url_1 = require("node:url"); +const node_worker_threads_1 = require("node:worker_threads"); +const environment_options_1 = require("../utils/environment-options"); +/** + * The maximum number of Workers that will be created to execute render requests. + */ +const MAX_RENDER_WORKERS = environment_options_1.maxWorkers; +/** + * A Sass renderer implementation that provides an interface that can be used by Webpack's + * `sass-loader`. The implementation uses a Worker thread to perform the Sass rendering + * with the `dart-sass` package. The `dart-sass` synchronous render function is used within + * the worker which can be up to two times faster than the asynchronous variant. + */ +class SassWorkerImplementation { + constructor(rebase = false) { + this.rebase = rebase; + this.workers = []; + this.availableWorkers = []; + this.requests = new Map(); + this.workerPath = (0, node_path_1.join)(__dirname, './worker.js'); + this.idCounter = 1; + this.nextWorkerIndex = 0; + } + /** + * Provides information about the Sass implementation. + * This mimics enough of the `dart-sass` value to be used with the `sass-loader`. + */ + get info() { + return 'dart-sass\tworker'; + } + /** + * The synchronous render function is not used by the `sass-loader`. + */ + compileString() { + throw new Error('Sass compileString is not supported.'); + } + /** + * Asynchronously request a Sass stylesheet to be renderered. + * + * @param source The contents to compile. + * @param options The `dart-sass` options to use when rendering the stylesheet. + */ + compileStringAsync(source, options) { + // The `functions`, `logger` and `importer` options are JavaScript functions that cannot be transferred. + // If any additional function options are added in the future, they must be excluded as well. + const { functions, importers, url, logger, ...serializableOptions } = options; + // The CLI's configuration does not use or expose the ability to defined custom Sass functions + if (functions && Object.keys(functions).length > 0) { + throw new Error('Sass custom functions are not supported.'); + } + return new Promise((resolve, reject) => { + let workerIndex = this.availableWorkers.pop(); + if (workerIndex === undefined) { + if (this.workers.length < MAX_RENDER_WORKERS) { + workerIndex = this.workers.length; + this.workers.push(this.createWorker()); + } + else { + workerIndex = this.nextWorkerIndex++; + if (this.nextWorkerIndex >= this.workers.length) { + this.nextWorkerIndex = 0; + } + } + } + const callback = (error, result) => { + if (error) { + const url = error.span?.url; + if (url) { + error.span.url = (0, node_url_1.pathToFileURL)(url); + } + reject(error); + return; + } + if (!result) { + reject(new Error('No result.')); + return; + } + resolve(result); + }; + const request = this.createRequest(workerIndex, callback, logger, importers); + this.requests.set(request.id, request); + this.workers[workerIndex].postMessage({ + id: request.id, + source, + hasImporter: !!importers?.length, + hasLogger: !!logger, + rebase: this.rebase, + options: { + ...serializableOptions, + // URL is not serializable so to convert to string here and back to URL in the worker. + url: url ? (0, node_url_1.fileURLToPath)(url) : undefined, + }, + }); + }); + } + /** + * Shutdown the Sass render worker. + * Executing this method will stop any pending render requests. + */ + close() { + for (const worker of this.workers) { + try { + void worker.terminate(); + } + catch { } + } + this.requests.clear(); + } + createWorker() { + const { port1: mainImporterPort, port2: workerImporterPort } = new node_worker_threads_1.MessageChannel(); + const importerSignal = new Int32Array(new SharedArrayBuffer(4)); + const worker = new node_worker_threads_1.Worker(this.workerPath, { + workerData: { workerImporterPort, importerSignal }, + transferList: [workerImporterPort], + }); + worker.on('message', (response) => { + const request = this.requests.get(response.id); + if (!request) { + return; + } + this.requests.delete(response.id); + this.availableWorkers.push(request.workerIndex); + if (response.warnings && request.logger?.warn) { + for (const { message, span, ...options } of response.warnings) { + request.logger.warn(message, { + ...options, + span: span && { + ...span, + url: span.url ? (0, node_url_1.pathToFileURL)(span.url) : undefined, + }, + }); + } + } + if (response.result) { + request.callback(undefined, { + ...response.result, + // URL is not serializable so in the worker we convert to string and here back to URL. + loadedUrls: response.result.loadedUrls.map((p) => (0, node_url_1.pathToFileURL)(p)), + }); + } + else { + request.callback(response.error); + } + }); + mainImporterPort.on('message', ({ id, url, options }) => { + const request = this.requests.get(id); + if (!request?.importers) { + mainImporterPort.postMessage(null); + Atomics.store(importerSignal, 0, 1); + Atomics.notify(importerSignal, 0); + return; + } + this.processImporters(request.importers, url, { + ...options, + previousResolvedModules: request.previousResolvedModules, + }) + .then((result) => { + if (result) { + request.previousResolvedModules ?? (request.previousResolvedModules = new Set()); + request.previousResolvedModules.add((0, node_path_1.dirname)(result)); + } + mainImporterPort.postMessage(result); + }) + .catch((error) => { + mainImporterPort.postMessage(error); + }) + .finally(() => { + Atomics.store(importerSignal, 0, 1); + Atomics.notify(importerSignal, 0); + }); + }); + mainImporterPort.unref(); + return worker; + } + async processImporters(importers, url, options) { + for (const importer of importers) { + if (this.isImporter(importer)) { + // Importer + throw new Error('Only File Importers are supported.'); + } + // File importer (Can be sync or aync). + const result = await importer.findFileUrl(url, options); + if (result) { + return (0, node_url_1.fileURLToPath)(result); + } + } + return null; + } + createRequest(workerIndex, callback, logger, importers) { + return { + id: this.idCounter++, + workerIndex, + callback, + logger, + importers, + }; + } + isImporter(value) { + return 'canonicalize' in value && 'load' in value; + } +} +exports.SassWorkerImplementation = SassWorkerImplementation; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sass-service.js","sourceRoot":"","sources":["../../../../../../../../packages/angular_devkit/build_angular/src/sass/sass-service.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 { dirname, join } from 'node:path';\nimport { fileURLToPath, pathToFileURL } from 'node:url';\nimport { MessageChannel, Worker } from 'node:worker_threads';\nimport {\n  CompileResult,\n  Exception,\n  FileImporter,\n  Importer,\n  Logger,\n  SourceSpan,\n  StringOptionsWithImporter,\n  StringOptionsWithoutImporter,\n} from 'sass';\nimport { maxWorkers } from '../utils/environment-options';\n\n/**\n * The maximum number of Workers that will be created to execute render requests.\n */\nconst MAX_RENDER_WORKERS = maxWorkers;\n\n/**\n * The callback type for the `dart-sass` asynchronous render function.\n */\ntype RenderCallback = (error?: Exception, result?: CompileResult) => void;\n\ntype FileImporterOptions = Parameters<FileImporter['findFileUrl']>[1];\n\nexport interface FileImporterWithRequestContextOptions extends FileImporterOptions {\n  /**\n   * This is a custom option and is required as SASS does not provide context from which the file is being resolved.\n   * This breaks Yarn PNP as transitive deps cannot be resolved from the workspace root.\n   *\n   * Workaround until https://github.com/sass/sass/issues/3247 is addressed.\n   */\n  previousResolvedModules?: Set<string>;\n}\n\n/**\n * An object containing the contextual information for a specific render request.\n */\ninterface RenderRequest {\n  id: number;\n  workerIndex: number;\n  callback: RenderCallback;\n  logger?: Logger;\n  importers?: Importers[];\n  previousResolvedModules?: Set<string>;\n}\n\n/**\n * All available importer types.\n */\ntype Importers =\n  | Importer<'sync'>\n  | Importer<'async'>\n  | FileImporter<'sync'>\n  | FileImporter<'async'>;\n\n/**\n * A response from the Sass render Worker containing the result of the operation.\n */\ninterface RenderResponseMessage {\n  id: number;\n  error?: Exception;\n  result?: Omit<CompileResult, 'loadedUrls'> & { loadedUrls: string[] };\n  warnings?: {\n    message: string;\n    deprecation: boolean;\n    stack?: string;\n    span?: Omit<SourceSpan, 'url'> & { url?: string };\n  }[];\n}\n\n/**\n * A Sass renderer implementation that provides an interface that can be used by Webpack's\n * `sass-loader`. The implementation uses a Worker thread to perform the Sass rendering\n * with the `dart-sass` package.  The `dart-sass` synchronous render function is used within\n * the worker which can be up to two times faster than the asynchronous variant.\n */\nexport class SassWorkerImplementation {\n  private readonly workers: Worker[] = [];\n  private readonly availableWorkers: number[] = [];\n  private readonly requests = new Map<number, RenderRequest>();\n  private readonly workerPath = join(__dirname, './worker.js');\n  private idCounter = 1;\n  private nextWorkerIndex = 0;\n\n  constructor(private rebase = false) {}\n\n  /**\n   * Provides information about the Sass implementation.\n   * This mimics enough of the `dart-sass` value to be used with the `sass-loader`.\n   */\n  get info(): string {\n    return 'dart-sass\\tworker';\n  }\n\n  /**\n   * The synchronous render function is not used by the `sass-loader`.\n   */\n  compileString(): never {\n    throw new Error('Sass compileString is not supported.');\n  }\n\n  /**\n   * Asynchronously request a Sass stylesheet to be renderered.\n   *\n   * @param source The contents to compile.\n   * @param options The `dart-sass` options to use when rendering the stylesheet.\n   */\n  compileStringAsync(\n    source: string,\n    options: StringOptionsWithImporter<'async'> | StringOptionsWithoutImporter<'async'>,\n  ): Promise<CompileResult> {\n    // The `functions`, `logger` and `importer` options are JavaScript functions that cannot be transferred.\n    // If any additional function options are added in the future, they must be excluded as well.\n    const { functions, importers, url, logger, ...serializableOptions } = options;\n\n    // The CLI's configuration does not use or expose the ability to defined custom Sass functions\n    if (functions && Object.keys(functions).length > 0) {\n      throw new Error('Sass custom functions are not supported.');\n    }\n\n    return new Promise<CompileResult>((resolve, reject) => {\n      let workerIndex = this.availableWorkers.pop();\n      if (workerIndex === undefined) {\n        if (this.workers.length < MAX_RENDER_WORKERS) {\n          workerIndex = this.workers.length;\n          this.workers.push(this.createWorker());\n        } else {\n          workerIndex = this.nextWorkerIndex++;\n          if (this.nextWorkerIndex >= this.workers.length) {\n            this.nextWorkerIndex = 0;\n          }\n        }\n      }\n\n      const callback: RenderCallback = (error, result) => {\n        if (error) {\n          const url = error.span?.url as string | undefined;\n          if (url) {\n            error.span.url = pathToFileURL(url);\n          }\n\n          reject(error);\n\n          return;\n        }\n\n        if (!result) {\n          reject(new Error('No result.'));\n\n          return;\n        }\n\n        resolve(result);\n      };\n\n      const request = this.createRequest(workerIndex, callback, logger, importers);\n      this.requests.set(request.id, request);\n\n      this.workers[workerIndex].postMessage({\n        id: request.id,\n        source,\n        hasImporter: !!importers?.length,\n        hasLogger: !!logger,\n        rebase: this.rebase,\n        options: {\n          ...serializableOptions,\n          // URL is not serializable so to convert to string here and back to URL in the worker.\n          url: url ? fileURLToPath(url) : undefined,\n        },\n      });\n    });\n  }\n\n  /**\n   * Shutdown the Sass render worker.\n   * Executing this method will stop any pending render requests.\n   */\n  close(): void {\n    for (const worker of this.workers) {\n      try {\n        void worker.terminate();\n      } catch {}\n    }\n    this.requests.clear();\n  }\n\n  private createWorker(): Worker {\n    const { port1: mainImporterPort, port2: workerImporterPort } = new MessageChannel();\n    const importerSignal = new Int32Array(new SharedArrayBuffer(4));\n\n    const worker = new Worker(this.workerPath, {\n      workerData: { workerImporterPort, importerSignal },\n      transferList: [workerImporterPort],\n    });\n\n    worker.on('message', (response: RenderResponseMessage) => {\n      const request = this.requests.get(response.id);\n      if (!request) {\n        return;\n      }\n\n      this.requests.delete(response.id);\n      this.availableWorkers.push(request.workerIndex);\n\n      if (response.warnings && request.logger?.warn) {\n        for (const { message, span, ...options } of response.warnings) {\n          request.logger.warn(message, {\n            ...options,\n            span: span && {\n              ...span,\n              url: span.url ? pathToFileURL(span.url) : undefined,\n            },\n          });\n        }\n      }\n\n      if (response.result) {\n        request.callback(undefined, {\n          ...response.result,\n          // URL is not serializable so in the worker we convert to string and here back to URL.\n          loadedUrls: response.result.loadedUrls.map((p) => pathToFileURL(p)),\n        });\n      } else {\n        request.callback(response.error);\n      }\n    });\n\n    mainImporterPort.on(\n      'message',\n      ({ id, url, options }: { id: number; url: string; options: FileImporterOptions }) => {\n        const request = this.requests.get(id);\n        if (!request?.importers) {\n          mainImporterPort.postMessage(null);\n          Atomics.store(importerSignal, 0, 1);\n          Atomics.notify(importerSignal, 0);\n\n          return;\n        }\n\n        this.processImporters(request.importers, url, {\n          ...options,\n          previousResolvedModules: request.previousResolvedModules,\n        })\n          .then((result) => {\n            if (result) {\n              request.previousResolvedModules ??= new Set();\n              request.previousResolvedModules.add(dirname(result));\n            }\n\n            mainImporterPort.postMessage(result);\n          })\n          .catch((error) => {\n            mainImporterPort.postMessage(error);\n          })\n          .finally(() => {\n            Atomics.store(importerSignal, 0, 1);\n            Atomics.notify(importerSignal, 0);\n          });\n      },\n    );\n\n    mainImporterPort.unref();\n\n    return worker;\n  }\n\n  private async processImporters(\n    importers: Iterable<Importers>,\n    url: string,\n    options: FileImporterWithRequestContextOptions,\n  ): Promise<string | null> {\n    for (const importer of importers) {\n      if (this.isImporter(importer)) {\n        // Importer\n        throw new Error('Only File Importers are supported.');\n      }\n\n      // File importer (Can be sync or aync).\n      const result = await importer.findFileUrl(url, options);\n      if (result) {\n        return fileURLToPath(result);\n      }\n    }\n\n    return null;\n  }\n\n  private createRequest(\n    workerIndex: number,\n    callback: RenderCallback,\n    logger: Logger | undefined,\n    importers: Importers[] | undefined,\n  ): RenderRequest {\n    return {\n      id: this.idCounter++,\n      workerIndex,\n      callback,\n      logger,\n      importers,\n    };\n  }\n\n  private isImporter(value: Importers): value is Importer {\n    return 'canonicalize' in value && 'load' in value;\n  }\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/sass/worker-legacy.d.ts b/artifacts/build-angular/src/sass/worker-legacy.d.ts new file mode 100644 index 00000000..15fb6380 --- /dev/null +++ b/artifacts/build-angular/src/sass/worker-legacy.d.ts @@ -0,0 +1,8 @@ +/** + * @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 + */ +export {}; diff --git a/artifacts/build-angular/src/sass/worker-legacy.js b/artifacts/build-angular/src/sass/worker-legacy.js new file mode 100644 index 00000000..66549927 --- /dev/null +++ b/artifacts/build-angular/src/sass/worker-legacy.js @@ -0,0 +1,44 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const sass_1 = require("sass"); +const worker_threads_1 = require("worker_threads"); +if (!worker_threads_1.parentPort || !worker_threads_1.workerData) { + throw new Error('Sass worker must be executed as a Worker.'); +} +// The importer variables are used to proxy import requests to the main thread +const { workerImporterPort, importerSignal } = worker_threads_1.workerData; +worker_threads_1.parentPort.on('message', ({ id, hasImporter, options }) => { + try { + if (hasImporter) { + // When a custom importer function is present, the importer request must be proxied + // back to the main thread where it can be executed. + // This process must be synchronous from the perspective of dart-sass. The `Atomics` + // functions combined with the shared memory `importSignal` and the Node.js + // `receiveMessageOnPort` function are used to ensure synchronous behavior. + options.importer = function (url, prev) { + Atomics.store(importerSignal, 0, 0); + const { fromImport } = this; + workerImporterPort.postMessage({ id, url, prev, fromImport }); + Atomics.wait(importerSignal, 0, 0); + return (0, worker_threads_1.receiveMessageOnPort)(workerImporterPort)?.message; + }; + } + // The synchronous Sass render function can be up to two times faster than the async variant + const result = (0, sass_1.renderSync)(options); + worker_threads_1.parentPort?.postMessage({ id, result }); + // eslint-disable-next-line @typescript-eslint/no-explicit-any + } + catch (error) { + // Needed because V8 will only serialize the message and stack properties of an Error instance. + const { formatted, file, line, column, message, stack } = error; + worker_threads_1.parentPort?.postMessage({ id, error: { formatted, file, line, column, message, stack } }); + } +}); +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/sass/worker.d.ts b/artifacts/build-angular/src/sass/worker.d.ts new file mode 100644 index 00000000..15fb6380 --- /dev/null +++ b/artifacts/build-angular/src/sass/worker.d.ts @@ -0,0 +1,8 @@ +/** + * @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 + */ +export {}; diff --git a/artifacts/build-angular/src/sass/worker.js b/artifacts/build-angular/src/sass/worker.js new file mode 100644 index 00000000..7c2354a8 --- /dev/null +++ b/artifacts/build-angular/src/sass/worker.js @@ -0,0 +1,158 @@ +"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 __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const remapping_1 = __importDefault(require("@ampproject/remapping")); +const node_path_1 = require("node:path"); +const node_url_1 = require("node:url"); +const node_worker_threads_1 = require("node:worker_threads"); +const sass_1 = require("sass"); +const rebasing_importer_1 = require("./rebasing-importer"); +if (!node_worker_threads_1.parentPort || !node_worker_threads_1.workerData) { + throw new Error('Sass worker must be executed as a Worker.'); +} +// The importer variables are used to proxy import requests to the main thread +const { workerImporterPort, importerSignal } = node_worker_threads_1.workerData; +node_worker_threads_1.parentPort.on('message', (message) => { + if (!node_worker_threads_1.parentPort) { + throw new Error('"parentPort" is not defined. Sass worker must be executed as a Worker.'); + } + const { id, hasImporter, hasLogger, source, options, rebase } = message; + const entryDirectory = (0, node_path_1.dirname)(options.url); + let warnings; + try { + const directoryCache = new Map(); + const rebaseSourceMaps = options.sourceMap ? new Map() : undefined; + if (hasImporter) { + // When a custom importer function is present, the importer request must be proxied + // back to the main thread where it can be executed. + // This process must be synchronous from the perspective of dart-sass. The `Atomics` + // functions combined with the shared memory `importSignal` and the Node.js + // `receiveMessageOnPort` function are used to ensure synchronous behavior. + const proxyImporter = { + findFileUrl: (url, options) => { + Atomics.store(importerSignal, 0, 0); + workerImporterPort.postMessage({ id, url, options }); + Atomics.wait(importerSignal, 0, 0); + const result = (0, node_worker_threads_1.receiveMessageOnPort)(workerImporterPort)?.message; + return result ? (0, node_url_1.pathToFileURL)(result) : null; + }, + }; + options.importers = [ + rebase + ? (0, rebasing_importer_1.sassBindWorkaround)(new rebasing_importer_1.ModuleUrlRebasingImporter(entryDirectory, directoryCache, rebaseSourceMaps, proxyImporter.findFileUrl)) + : proxyImporter, + ]; + } + if (rebase && options.loadPaths?.length) { + options.importers ?? (options.importers = []); + options.importers.push((0, rebasing_importer_1.sassBindWorkaround)(new rebasing_importer_1.LoadPathsUrlRebasingImporter(entryDirectory, directoryCache, rebaseSourceMaps, options.loadPaths))); + options.loadPaths = undefined; + } + let relativeImporter; + if (rebase) { + relativeImporter = (0, rebasing_importer_1.sassBindWorkaround)(new rebasing_importer_1.RelativeUrlRebasingImporter(entryDirectory, directoryCache, rebaseSourceMaps)); + } + // The synchronous Sass render function can be up to two times faster than the async variant + const result = (0, sass_1.compileString)(source, { + ...options, + // URL is not serializable so to convert to string in the parent and back to URL here. + url: (0, node_url_1.pathToFileURL)(options.url), + // The `importer` option (singular) handles relative imports + importer: relativeImporter, + logger: hasLogger + ? { + warn(message, { deprecation, span, stack }) { + warnings ?? (warnings = []); + warnings.push({ + message, + deprecation, + stack, + span: span && convertSourceSpan(span), + }); + }, + } + : undefined, + }); + if (result.sourceMap && rebaseSourceMaps?.size) { + // Merge the intermediate rebasing source maps into the final Sass generated source map. + // Casting is required due to small but compatible differences in typings between the packages. + result.sourceMap = (0, remapping_1.default)(result.sourceMap, + // To prevent an infinite lookup loop, skip getting the source when the rebasing source map + // is referencing its original self. + (file, context) => (file !== context.importer ? rebaseSourceMaps.get(file) : null)); + } + node_worker_threads_1.parentPort.postMessage({ + id, + warnings, + result: { + ...result, + // URL is not serializable so to convert to string here and back to URL in the parent. + loadedUrls: result.loadedUrls.map((p) => (0, node_url_1.fileURLToPath)(p)), + }, + }); + } + catch (error) { + // Needed because V8 will only serialize the message and stack properties of an Error instance. + if (error instanceof sass_1.Exception) { + const { span, message, stack, sassMessage, sassStack } = error; + node_worker_threads_1.parentPort.postMessage({ + id, + warnings, + error: { + span: convertSourceSpan(span), + message, + stack, + sassMessage, + sassStack, + }, + }); + } + else if (error instanceof Error) { + const { message, stack } = error; + node_worker_threads_1.parentPort.postMessage({ id, warnings, error: { message, stack } }); + } + else { + node_worker_threads_1.parentPort.postMessage({ + id, + warnings, + error: { message: 'An unknown error has occurred.' }, + }); + } + } +}); +/** + * Converts a Sass SourceSpan object into a serializable form. + * The SourceSpan object contains a URL property which must be converted into a string. + * Also, most of the interface's properties are get accessors and are not automatically + * serialized when sent back from the worker. + * + * @param span The Sass SourceSpan object to convert. + * @returns A serializable form of the SourceSpan object. + */ +function convertSourceSpan(span) { + return { + text: span.text, + context: span.context, + end: { + column: span.end.column, + offset: span.end.offset, + line: span.end.line, + }, + start: { + column: span.start.column, + offset: span.start.offset, + line: span.start.line, + }, + url: span.url ? (0, node_url_1.fileURLToPath)(span.url) : undefined, + }; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"worker.js","sourceRoot":"","sources":["../../../../../../../../packages/angular_devkit/build_angular/src/sass/worker.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 mergeSourceMaps, { RawSourceMap } from '@ampproject/remapping';\nimport { dirname } from 'node:path';\nimport { fileURLToPath, pathToFileURL } from 'node:url';\nimport { MessagePort, parentPort, receiveMessageOnPort, workerData } from 'node:worker_threads';\nimport {\n  Exception,\n  FileImporter,\n  SourceSpan,\n  StringOptionsWithImporter,\n  compileString,\n} from 'sass';\nimport {\n  DirectoryEntry,\n  LoadPathsUrlRebasingImporter,\n  ModuleUrlRebasingImporter,\n  RelativeUrlRebasingImporter,\n  sassBindWorkaround,\n} from './rebasing-importer';\n\n/**\n * A request to render a Sass stylesheet using the supplied options.\n */\ninterface RenderRequestMessage {\n  /**\n   * The unique request identifier that links the render action with a callback and optional\n   * importer on the main thread.\n   */\n  id: number;\n  /**\n   * The contents to compile.\n   */\n  source: string;\n  /**\n   * The Sass options to provide to the `dart-sass` compile function.\n   */\n  options: Omit<StringOptionsWithImporter<'sync'>, 'url'> & { url: string };\n  /**\n   * Indicates the request has a custom importer function on the main thread.\n   */\n  hasImporter: boolean;\n  /**\n   * Indicates the request has a custom logger for warning messages.\n   */\n  hasLogger: boolean;\n  /**\n   * Indicates paths within url() CSS functions should be rebased.\n   */\n  rebase: boolean;\n}\n\nif (!parentPort || !workerData) {\n  throw new Error('Sass worker must be executed as a Worker.');\n}\n\n// The importer variables are used to proxy import requests to the main thread\nconst { workerImporterPort, importerSignal } = workerData as {\n  workerImporterPort: MessagePort;\n  importerSignal: Int32Array;\n};\n\nparentPort.on('message', (message: RenderRequestMessage) => {\n  if (!parentPort) {\n    throw new Error('\"parentPort\" is not defined. Sass worker must be executed as a Worker.');\n  }\n\n  const { id, hasImporter, hasLogger, source, options, rebase } = message;\n  const entryDirectory = dirname(options.url);\n  let warnings:\n    | {\n        message: string;\n        deprecation: boolean;\n        stack?: string;\n        span?: Omit<SourceSpan, 'url'> & { url?: string };\n      }[]\n    | undefined;\n  try {\n    const directoryCache = new Map<string, DirectoryEntry>();\n    const rebaseSourceMaps = options.sourceMap ? new Map<string, RawSourceMap>() : undefined;\n    if (hasImporter) {\n      // When a custom importer function is present, the importer request must be proxied\n      // back to the main thread where it can be executed.\n      // This process must be synchronous from the perspective of dart-sass. The `Atomics`\n      // functions combined with the shared memory `importSignal` and the Node.js\n      // `receiveMessageOnPort` function are used to ensure synchronous behavior.\n      const proxyImporter: FileImporter<'sync'> = {\n        findFileUrl: (url, options) => {\n          Atomics.store(importerSignal, 0, 0);\n          workerImporterPort.postMessage({ id, url, options });\n          Atomics.wait(importerSignal, 0, 0);\n\n          const result = receiveMessageOnPort(workerImporterPort)?.message as string | null;\n\n          return result ? pathToFileURL(result) : null;\n        },\n      };\n      options.importers = [\n        rebase\n          ? sassBindWorkaround(\n              new ModuleUrlRebasingImporter(\n                entryDirectory,\n                directoryCache,\n                rebaseSourceMaps,\n                proxyImporter.findFileUrl,\n              ),\n            )\n          : proxyImporter,\n      ];\n    }\n\n    if (rebase && options.loadPaths?.length) {\n      options.importers ??= [];\n      options.importers.push(\n        sassBindWorkaround(\n          new LoadPathsUrlRebasingImporter(\n            entryDirectory,\n            directoryCache,\n            rebaseSourceMaps,\n            options.loadPaths,\n          ),\n        ),\n      );\n      options.loadPaths = undefined;\n    }\n\n    let relativeImporter;\n    if (rebase) {\n      relativeImporter = sassBindWorkaround(\n        new RelativeUrlRebasingImporter(entryDirectory, directoryCache, rebaseSourceMaps),\n      );\n    }\n\n    // The synchronous Sass render function can be up to two times faster than the async variant\n    const result = compileString(source, {\n      ...options,\n      // URL is not serializable so to convert to string in the parent and back to URL here.\n      url: pathToFileURL(options.url),\n      // The `importer` option (singular) handles relative imports\n      importer: relativeImporter,\n      logger: hasLogger\n        ? {\n            warn(message, { deprecation, span, stack }) {\n              warnings ??= [];\n              warnings.push({\n                message,\n                deprecation,\n                stack,\n                span: span && convertSourceSpan(span),\n              });\n            },\n          }\n        : undefined,\n    });\n\n    if (result.sourceMap && rebaseSourceMaps?.size) {\n      // Merge the intermediate rebasing source maps into the final Sass generated source map.\n      // Casting is required due to small but compatible differences in typings between the packages.\n      result.sourceMap = mergeSourceMaps(\n        result.sourceMap as unknown as RawSourceMap,\n        // To prevent an infinite lookup loop, skip getting the source when the rebasing source map\n        // is referencing its original self.\n        (file, context) => (file !== context.importer ? rebaseSourceMaps.get(file) : null),\n      ) as unknown as typeof result.sourceMap;\n    }\n\n    parentPort.postMessage({\n      id,\n      warnings,\n      result: {\n        ...result,\n        // URL is not serializable so to convert to string here and back to URL in the parent.\n        loadedUrls: result.loadedUrls.map((p) => fileURLToPath(p)),\n      },\n    });\n  } catch (error) {\n    // Needed because V8 will only serialize the message and stack properties of an Error instance.\n    if (error instanceof Exception) {\n      const { span, message, stack, sassMessage, sassStack } = error;\n      parentPort.postMessage({\n        id,\n        warnings,\n        error: {\n          span: convertSourceSpan(span),\n          message,\n          stack,\n          sassMessage,\n          sassStack,\n        },\n      });\n    } else if (error instanceof Error) {\n      const { message, stack } = error;\n      parentPort.postMessage({ id, warnings, error: { message, stack } });\n    } else {\n      parentPort.postMessage({\n        id,\n        warnings,\n        error: { message: 'An unknown error has occurred.' },\n      });\n    }\n  }\n});\n\n/**\n * Converts a Sass SourceSpan object into a serializable form.\n * The SourceSpan object contains a URL property which must be converted into a string.\n * Also, most of the interface's properties are get accessors and are not automatically\n * serialized when sent back from the worker.\n *\n * @param span The Sass SourceSpan object to convert.\n * @returns A serializable form of the SourceSpan object.\n */\nfunction convertSourceSpan(span: SourceSpan): Omit<SourceSpan, 'url'> & { url?: string } {\n  return {\n    text: span.text,\n    context: span.context,\n    end: {\n      column: span.end.column,\n      offset: span.end.offset,\n      line: span.end.line,\n    },\n    start: {\n      column: span.start.column,\n      offset: span.start.offset,\n      line: span.start.line,\n    },\n    url: span.url ? fileURLToPath(span.url) : undefined,\n  };\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/transforms.d.ts b/artifacts/build-angular/src/transforms.d.ts new file mode 100644 index 00000000..2e6399ca --- /dev/null +++ b/artifacts/build-angular/src/transforms.d.ts @@ -0,0 +1,8 @@ +/** + * @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 + */ +export type ExecutionTransformer = (input: T) => T | Promise; diff --git a/artifacts/build-angular/src/transforms.js b/artifacts/build-angular/src/transforms.js new file mode 100644 index 00000000..50f6361b --- /dev/null +++ b/artifacts/build-angular/src/transforms.js @@ -0,0 +1,10 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNmb3Jtcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2FuZ3VsYXJfZGV2a2l0L2J1aWxkX2FuZ3VsYXIvc3JjL3RyYW5zZm9ybXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7R0FNRyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQgdHlwZSBFeGVjdXRpb25UcmFuc2Zvcm1lcjxUPiA9IChpbnB1dDogVCkgPT4gVCB8IFByb21pc2U8VD47XG4iXX0= \ No newline at end of file diff --git a/artifacts/build-angular/src/typings.d.ts b/artifacts/build-angular/src/typings.d.ts new file mode 100644 index 00000000..2468d5b2 --- /dev/null +++ b/artifacts/build-angular/src/typings.d.ts @@ -0,0 +1,21 @@ +/** + * @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 + */ + +declare module '@babel/helper-annotate-as-pure' { + export default function annotateAsPure( + pathOrNode: import('@babel/types').Node | { node: import('@babel/types').Node }, + ): void; +} + +declare module '@babel/helper-split-export-declaration' { + export default function splitExportDeclaration( + exportDeclaration: import('@babel/traverse').NodePath< + import('@babel/types').ExportDefaultDeclaration + >, + ): void; +} diff --git a/artifacts/build-angular/src/utils/action-executor.d.ts b/artifacts/build-angular/src/utils/action-executor.d.ts new file mode 100644 index 00000000..8cf0d46e --- /dev/null +++ b/artifacts/build-angular/src/utils/action-executor.d.ts @@ -0,0 +1,35 @@ +/** + * @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 { InlineOptions } from './bundle-inline-options'; +import { I18nOptions } from './i18n-options'; +export declare class BundleActionExecutor { + private workerOptions; + private workerPool?; + constructor(workerOptions: { + i18n: I18nOptions; + }); + private ensureWorkerPool; + inline(action: InlineOptions): Promise<{ + file: string; + diagnostics: { + type: string; + message: string; + }[]; + count: number; + }>; + inlineAll(actions: Iterable): AsyncIterable<{ + file: string; + diagnostics: { + type: string; + message: string; + }[]; + count: number; + }>; + private static executeAll; + stop(): void; +} diff --git a/artifacts/build-angular/src/utils/action-executor.js b/artifacts/build-angular/src/utils/action-executor.js new file mode 100644 index 00000000..075153ae --- /dev/null +++ b/artifacts/build-angular/src/utils/action-executor.js @@ -0,0 +1,56 @@ +"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 __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.BundleActionExecutor = void 0; +const piscina_1 = __importDefault(require("piscina")); +const environment_options_1 = require("./environment-options"); +const workerFile = require.resolve('./process-bundle'); +class BundleActionExecutor { + constructor(workerOptions) { + this.workerOptions = workerOptions; + } + ensureWorkerPool() { + if (this.workerPool) { + return this.workerPool; + } + this.workerPool = new piscina_1.default({ + filename: workerFile, + name: 'inlineLocales', + workerData: this.workerOptions, + maxThreads: environment_options_1.maxWorkers, + }); + return this.workerPool; + } + async inline(action) { + return this.ensureWorkerPool().run(action, { name: 'inlineLocales' }); + } + inlineAll(actions) { + return BundleActionExecutor.executeAll(actions, (action) => this.inline(action)); + } + static async *executeAll(actions, executor) { + const executions = new Map(); + for (const action of actions) { + const execution = executor(action); + executions.set(execution, execution.then((result) => [execution, result])); + } + while (executions.size > 0) { + const [execution, result] = await Promise.race(executions.values()); + executions.delete(execution); + yield result; + } + } + stop() { + void this.workerPool?.destroy(); + } +} +exports.BundleActionExecutor = BundleActionExecutor; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/utils/build-options.d.ts b/artifacts/build-angular/src/utils/build-options.d.ts new file mode 100644 index 00000000..b6137a2b --- /dev/null +++ b/artifacts/build-angular/src/utils/build-options.d.ts @@ -0,0 +1,75 @@ +/** + * @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 type { ParsedConfiguration } from '@angular/compiler-cli'; +import { logging } from '@angular-devkit/core'; +import { AssetPatternClass, Budget, CrossOrigin, I18NTranslation, IndexUnion, InlineStyleLanguage, Localize, OutputHashing, ScriptElement, SourceMapClass, StyleElement } from '../builders/browser/schema'; +import { Schema as DevServerSchema } from '../builders/dev-server/schema'; +import { NormalizedCachedOptions } from './normalize-cache'; +import { NormalizedFileReplacement } from './normalize-file-replacements'; +import { NormalizedOptimizationOptions } from './normalize-optimization'; +export interface BuildOptions { + optimization: NormalizedOptimizationOptions; + environment?: string; + outputPath: string; + resourcesOutputPath?: string; + aot?: boolean; + sourceMap: SourceMapClass; + vendorChunk?: boolean; + commonChunk?: boolean; + baseHref?: string; + deployUrl?: string; + verbose?: boolean; + progress?: boolean; + localize?: Localize; + i18nMissingTranslation?: I18NTranslation; + externalDependencies?: string[]; + watch?: boolean; + outputHashing?: OutputHashing; + poll?: number; + index?: IndexUnion; + deleteOutputPath?: boolean; + preserveSymlinks?: boolean; + extractLicenses?: boolean; + buildOptimizer?: boolean; + namedChunks?: boolean; + crossOrigin?: CrossOrigin; + subresourceIntegrity?: boolean; + serviceWorker?: boolean; + webWorkerTsConfig?: string; + statsJson: boolean; + hmr?: boolean; + main: string; + polyfills: string[]; + budgets: Budget[]; + assets: AssetPatternClass[]; + scripts: ScriptElement[]; + styles: StyleElement[]; + stylePreprocessorOptions?: { + includePaths: string[]; + }; + platform?: 'browser' | 'server'; + fileReplacements: NormalizedFileReplacement[]; + inlineStyleLanguage?: InlineStyleLanguage; + allowedCommonJsDependencies?: string[]; + cache: NormalizedCachedOptions; + codeCoverage?: boolean; + codeCoverageExclude?: string[]; + supportedBrowsers?: string[]; +} +export interface WebpackDevServerOptions extends BuildOptions, Omit { +} +export interface WebpackConfigOptions { + root: string; + logger: logging.Logger; + projectRoot: string; + sourceRoot?: string; + buildOptions: T; + tsConfig: ParsedConfiguration; + tsConfigPath: string; + projectName: string; +} diff --git a/artifacts/build-angular/src/utils/build-options.js b/artifacts/build-angular/src/utils/build-options.js new file mode 100644 index 00000000..df913d3a --- /dev/null +++ b/artifacts/build-angular/src/utils/build-options.js @@ -0,0 +1,10 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/utils/bundle-calculator.d.ts b/artifacts/build-angular/src/utils/bundle-calculator.d.ts new file mode 100644 index 00000000..fcde6e70 --- /dev/null +++ b/artifacts/build-angular/src/utils/bundle-calculator.d.ts @@ -0,0 +1,31 @@ +/** + * @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 { StatsCompilation } from 'webpack'; +import { Budget } from '../builders/browser/schema'; +interface Threshold { + limit: number; + type: ThresholdType; + severity: ThresholdSeverity; +} +declare enum ThresholdType { + Max = "maximum", + Min = "minimum" +} +export declare enum ThresholdSeverity { + Warning = "warning", + Error = "error" +} +export interface BudgetCalculatorResult { + severity: ThresholdSeverity; + message: string; + label?: string; +} +export declare function calculateThresholds(budget: Budget): IterableIterator; +export declare function checkBudgets(budgets: Budget[], webpackStats: StatsCompilation): IterableIterator; +export declare function checkThresholds(thresholds: IterableIterator, size: number, label?: string): IterableIterator; +export {}; diff --git a/artifacts/build-angular/src/utils/bundle-calculator.js b/artifacts/build-angular/src/utils/bundle-calculator.js new file mode 100644 index 00000000..652538f1 --- /dev/null +++ b/artifacts/build-angular/src/utils/bundle-calculator.js @@ -0,0 +1,289 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.checkThresholds = exports.checkBudgets = exports.calculateThresholds = exports.ThresholdSeverity = void 0; +const schema_1 = require("../builders/browser/schema"); +const stats_1 = require("../webpack/utils/stats"); +var ThresholdType; +(function (ThresholdType) { + ThresholdType["Max"] = "maximum"; + ThresholdType["Min"] = "minimum"; +})(ThresholdType || (ThresholdType = {})); +var ThresholdSeverity; +(function (ThresholdSeverity) { + ThresholdSeverity["Warning"] = "warning"; + ThresholdSeverity["Error"] = "error"; +})(ThresholdSeverity = exports.ThresholdSeverity || (exports.ThresholdSeverity = {})); +function* calculateThresholds(budget) { + if (budget.maximumWarning) { + yield { + limit: calculateBytes(budget.maximumWarning, budget.baseline, 1), + type: ThresholdType.Max, + severity: ThresholdSeverity.Warning, + }; + } + if (budget.maximumError) { + yield { + limit: calculateBytes(budget.maximumError, budget.baseline, 1), + type: ThresholdType.Max, + severity: ThresholdSeverity.Error, + }; + } + if (budget.minimumWarning) { + yield { + limit: calculateBytes(budget.minimumWarning, budget.baseline, -1), + type: ThresholdType.Min, + severity: ThresholdSeverity.Warning, + }; + } + if (budget.minimumError) { + yield { + limit: calculateBytes(budget.minimumError, budget.baseline, -1), + type: ThresholdType.Min, + severity: ThresholdSeverity.Error, + }; + } + if (budget.warning) { + yield { + limit: calculateBytes(budget.warning, budget.baseline, -1), + type: ThresholdType.Min, + severity: ThresholdSeverity.Warning, + }; + yield { + limit: calculateBytes(budget.warning, budget.baseline, 1), + type: ThresholdType.Max, + severity: ThresholdSeverity.Warning, + }; + } + if (budget.error) { + yield { + limit: calculateBytes(budget.error, budget.baseline, -1), + type: ThresholdType.Min, + severity: ThresholdSeverity.Error, + }; + yield { + limit: calculateBytes(budget.error, budget.baseline, 1), + type: ThresholdType.Max, + severity: ThresholdSeverity.Error, + }; + } +} +exports.calculateThresholds = calculateThresholds; +/** + * Calculates the sizes for bundles in the budget type provided. + */ +function calculateSizes(budget, stats) { + if (budget.type === schema_1.Type.AnyComponentStyle) { + // Component style size information is not available post-build, this must + // be checked mid-build via the `AnyComponentStyleBudgetChecker` plugin. + throw new Error('Can not calculate size of AnyComponentStyle. Use `AnyComponentStyleBudgetChecker` instead.'); + } + const calculatorMap = { + all: AllCalculator, + allScript: AllScriptCalculator, + any: AnyCalculator, + anyScript: AnyScriptCalculator, + bundle: BundleCalculator, + initial: InitialCalculator, + }; + const ctor = calculatorMap[budget.type]; + const { chunks, assets } = stats; + if (!chunks) { + throw new Error('Webpack stats output did not include chunk information.'); + } + if (!assets) { + throw new Error('Webpack stats output did not include asset information.'); + } + const calculator = new ctor(budget, chunks, assets); + return calculator.calculate(); +} +class Calculator { + constructor(budget, chunks, assets) { + this.budget = budget; + this.chunks = chunks; + this.assets = assets; + } + /** Calculates the size of the given chunk for the provided build type. */ + calculateChunkSize(chunk) { + // No differential builds, get the chunk size by summing its assets. + if (!chunk.files) { + return 0; + } + return chunk.files + .filter((file) => !file.endsWith('.map')) + .map((file) => { + const asset = this.assets.find((asset) => asset.name === file); + if (!asset) { + throw new Error(`Could not find asset for file: ${file}`); + } + return asset.size; + }) + .reduce((l, r) => l + r, 0); + } + getAssetSize(asset) { + return asset.size; + } +} +/** + * A named bundle. + */ +class BundleCalculator extends Calculator { + calculate() { + const budgetName = this.budget.name; + if (!budgetName) { + return []; + } + const size = this.chunks + .filter((chunk) => chunk?.names?.includes(budgetName)) + .map((chunk) => this.calculateChunkSize(chunk)) + .reduce((l, r) => l + r, 0); + return [{ size, label: this.budget.name }]; + } +} +/** + * The sum of all initial chunks (marked as initial). + */ +class InitialCalculator extends Calculator { + calculate() { + return [ + { + label: `bundle initial`, + size: this.chunks + .filter((chunk) => chunk.initial) + .map((chunk) => this.calculateChunkSize(chunk)) + .reduce((l, r) => l + r, 0), + }, + ]; + } +} +/** + * The sum of all the scripts portions. + */ +class AllScriptCalculator extends Calculator { + calculate() { + const size = this.assets + .filter((asset) => asset.name.endsWith('.js')) + .map((asset) => this.getAssetSize(asset)) + .reduce((total, size) => total + size, 0); + return [{ size, label: 'total scripts' }]; + } +} +/** + * All scripts and assets added together. + */ +class AllCalculator extends Calculator { + calculate() { + const size = this.assets + .filter((asset) => !asset.name.endsWith('.map')) + .map((asset) => this.getAssetSize(asset)) + .reduce((total, size) => total + size, 0); + return [{ size, label: 'total' }]; + } +} +/** + * Any script, individually. + */ +class AnyScriptCalculator extends Calculator { + calculate() { + return this.assets + .filter((asset) => asset.name.endsWith('.js')) + .map((asset) => ({ + size: this.getAssetSize(asset), + label: asset.name, + })); + } +} +/** + * Any script or asset (images, css, etc). + */ +class AnyCalculator extends Calculator { + calculate() { + return this.assets + .filter((asset) => !asset.name.endsWith('.map')) + .map((asset) => ({ + size: this.getAssetSize(asset), + label: asset.name, + })); + } +} +/** + * Calculate the bytes given a string value. + */ +function calculateBytes(input, baseline, factor = 1) { + const matches = input.match(/^\s*(\d+(?:\.\d+)?)\s*(%|(?:[mM]|[kK]|[gG])?[bB])?\s*$/); + if (!matches) { + return NaN; + } + const baselineBytes = (baseline && calculateBytes(baseline)) || 0; + let value = Number(matches[1]); + switch (matches[2] && matches[2].toLowerCase()) { + case '%': + value = (baselineBytes * value) / 100; + break; + case 'kb': + value *= 1024; + break; + case 'mb': + value *= 1024 * 1024; + break; + case 'gb': + value *= 1024 * 1024 * 1024; + break; + } + if (baselineBytes === 0) { + return value; + } + return baselineBytes + value * factor; +} +function* checkBudgets(budgets, webpackStats) { + // Ignore AnyComponentStyle budgets as these are handled in `AnyComponentStyleBudgetChecker`. + const computableBudgets = budgets.filter((budget) => budget.type !== schema_1.Type.AnyComponentStyle); + for (const budget of computableBudgets) { + const sizes = calculateSizes(budget, webpackStats); + for (const { size, label } of sizes) { + yield* checkThresholds(calculateThresholds(budget), size, label); + } + } +} +exports.checkBudgets = checkBudgets; +function* checkThresholds(thresholds, size, label) { + for (const threshold of thresholds) { + switch (threshold.type) { + case ThresholdType.Max: { + if (size <= threshold.limit) { + continue; + } + const sizeDifference = (0, stats_1.formatSize)(size - threshold.limit); + yield { + severity: threshold.severity, + label, + message: `${label} exceeded maximum budget. Budget ${(0, stats_1.formatSize)(threshold.limit)} was not met by ${sizeDifference} with a total of ${(0, stats_1.formatSize)(size)}.`, + }; + break; + } + case ThresholdType.Min: { + if (size >= threshold.limit) { + continue; + } + const sizeDifference = (0, stats_1.formatSize)(threshold.limit - size); + yield { + severity: threshold.severity, + label, + message: `${label} failed to meet minimum budget. Budget ${(0, stats_1.formatSize)(threshold.limit)} was not met by ${sizeDifference} with a total of ${(0, stats_1.formatSize)(size)}.`, + }; + break; + } + default: { + throw new Error(`Unexpected threshold type: ${ThresholdType[threshold.type]}`); + } + } + } +} +exports.checkThresholds = checkThresholds; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bundle-calculator.js","sourceRoot":"","sources":["../../../../../../../../packages/angular_devkit/build_angular/src/utils/bundle-calculator.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 { StatsAsset, StatsChunk, StatsCompilation } from 'webpack';\nimport { Budget, Type } from '../builders/browser/schema';\nimport { formatSize } from '../webpack/utils/stats';\n\ninterface Size {\n  size: number;\n  label?: string;\n}\n\ninterface Threshold {\n  limit: number;\n  type: ThresholdType;\n  severity: ThresholdSeverity;\n}\n\nenum ThresholdType {\n  Max = 'maximum',\n  Min = 'minimum',\n}\n\nexport enum ThresholdSeverity {\n  Warning = 'warning',\n  Error = 'error',\n}\n\nexport interface BudgetCalculatorResult {\n  severity: ThresholdSeverity;\n  message: string;\n  label?: string;\n}\n\nexport function* calculateThresholds(budget: Budget): IterableIterator<Threshold> {\n  if (budget.maximumWarning) {\n    yield {\n      limit: calculateBytes(budget.maximumWarning, budget.baseline, 1),\n      type: ThresholdType.Max,\n      severity: ThresholdSeverity.Warning,\n    };\n  }\n\n  if (budget.maximumError) {\n    yield {\n      limit: calculateBytes(budget.maximumError, budget.baseline, 1),\n      type: ThresholdType.Max,\n      severity: ThresholdSeverity.Error,\n    };\n  }\n\n  if (budget.minimumWarning) {\n    yield {\n      limit: calculateBytes(budget.minimumWarning, budget.baseline, -1),\n      type: ThresholdType.Min,\n      severity: ThresholdSeverity.Warning,\n    };\n  }\n\n  if (budget.minimumError) {\n    yield {\n      limit: calculateBytes(budget.minimumError, budget.baseline, -1),\n      type: ThresholdType.Min,\n      severity: ThresholdSeverity.Error,\n    };\n  }\n\n  if (budget.warning) {\n    yield {\n      limit: calculateBytes(budget.warning, budget.baseline, -1),\n      type: ThresholdType.Min,\n      severity: ThresholdSeverity.Warning,\n    };\n\n    yield {\n      limit: calculateBytes(budget.warning, budget.baseline, 1),\n      type: ThresholdType.Max,\n      severity: ThresholdSeverity.Warning,\n    };\n  }\n\n  if (budget.error) {\n    yield {\n      limit: calculateBytes(budget.error, budget.baseline, -1),\n      type: ThresholdType.Min,\n      severity: ThresholdSeverity.Error,\n    };\n\n    yield {\n      limit: calculateBytes(budget.error, budget.baseline, 1),\n      type: ThresholdType.Max,\n      severity: ThresholdSeverity.Error,\n    };\n  }\n}\n\n/**\n * Calculates the sizes for bundles in the budget type provided.\n */\nfunction calculateSizes(budget: Budget, stats: StatsCompilation): Size[] {\n  if (budget.type === Type.AnyComponentStyle) {\n    // Component style size information is not available post-build, this must\n    // be checked mid-build via the `AnyComponentStyleBudgetChecker` plugin.\n    throw new Error(\n      'Can not calculate size of AnyComponentStyle. Use `AnyComponentStyleBudgetChecker` instead.',\n    );\n  }\n\n  type NonComponentStyleBudgetTypes = Exclude<Budget['type'], Type.AnyComponentStyle>;\n  type CalculatorTypes = {\n    new (budget: Budget, chunks: StatsChunk[], assets: StatsAsset[]): Calculator;\n  };\n  const calculatorMap: Record<NonComponentStyleBudgetTypes, CalculatorTypes> = {\n    all: AllCalculator,\n    allScript: AllScriptCalculator,\n    any: AnyCalculator,\n    anyScript: AnyScriptCalculator,\n    bundle: BundleCalculator,\n    initial: InitialCalculator,\n  };\n\n  const ctor = calculatorMap[budget.type];\n  const { chunks, assets } = stats;\n  if (!chunks) {\n    throw new Error('Webpack stats output did not include chunk information.');\n  }\n  if (!assets) {\n    throw new Error('Webpack stats output did not include asset information.');\n  }\n\n  const calculator = new ctor(budget, chunks, assets);\n\n  return calculator.calculate();\n}\n\nabstract class Calculator {\n  constructor(\n    protected budget: Budget,\n    protected chunks: StatsChunk[],\n    protected assets: StatsAsset[],\n  ) {}\n\n  abstract calculate(): Size[];\n\n  /** Calculates the size of the given chunk for the provided build type. */\n  protected calculateChunkSize(chunk: StatsChunk): number {\n    // No differential builds, get the chunk size by summing its assets.\n    if (!chunk.files) {\n      return 0;\n    }\n\n    return chunk.files\n      .filter((file) => !file.endsWith('.map'))\n      .map((file) => {\n        const asset = this.assets.find((asset) => asset.name === file);\n        if (!asset) {\n          throw new Error(`Could not find asset for file: ${file}`);\n        }\n\n        return asset.size;\n      })\n      .reduce((l, r) => l + r, 0);\n  }\n\n  protected getAssetSize(asset: StatsAsset): number {\n    return asset.size;\n  }\n}\n\n/**\n * A named bundle.\n */\nclass BundleCalculator extends Calculator {\n  calculate() {\n    const budgetName = this.budget.name;\n    if (!budgetName) {\n      return [];\n    }\n\n    const size = this.chunks\n      .filter((chunk) => chunk?.names?.includes(budgetName))\n      .map((chunk) => this.calculateChunkSize(chunk))\n      .reduce((l, r) => l + r, 0);\n\n    return [{ size, label: this.budget.name }];\n  }\n}\n\n/**\n * The sum of all initial chunks (marked as initial).\n */\nclass InitialCalculator extends Calculator {\n  calculate() {\n    return [\n      {\n        label: `bundle initial`,\n        size: this.chunks\n          .filter((chunk) => chunk.initial)\n          .map((chunk) => this.calculateChunkSize(chunk))\n          .reduce((l, r) => l + r, 0),\n      },\n    ];\n  }\n}\n\n/**\n * The sum of all the scripts portions.\n */\nclass AllScriptCalculator extends Calculator {\n  calculate() {\n    const size = this.assets\n      .filter((asset) => asset.name.endsWith('.js'))\n      .map((asset) => this.getAssetSize(asset))\n      .reduce((total: number, size: number) => total + size, 0);\n\n    return [{ size, label: 'total scripts' }];\n  }\n}\n\n/**\n * All scripts and assets added together.\n */\nclass AllCalculator extends Calculator {\n  calculate() {\n    const size = this.assets\n      .filter((asset) => !asset.name.endsWith('.map'))\n      .map((asset) => this.getAssetSize(asset))\n      .reduce((total: number, size: number) => total + size, 0);\n\n    return [{ size, label: 'total' }];\n  }\n}\n\n/**\n * Any script, individually.\n */\nclass AnyScriptCalculator extends Calculator {\n  calculate() {\n    return this.assets\n      .filter((asset) => asset.name.endsWith('.js'))\n      .map((asset) => ({\n        size: this.getAssetSize(asset),\n        label: asset.name,\n      }));\n  }\n}\n\n/**\n * Any script or asset (images, css, etc).\n */\nclass AnyCalculator extends Calculator {\n  calculate() {\n    return this.assets\n      .filter((asset) => !asset.name.endsWith('.map'))\n      .map((asset) => ({\n        size: this.getAssetSize(asset),\n        label: asset.name,\n      }));\n  }\n}\n\n/**\n * Calculate the bytes given a string value.\n */\nfunction calculateBytes(input: string, baseline?: string, factor: 1 | -1 = 1): number {\n  const matches = input.match(/^\\s*(\\d+(?:\\.\\d+)?)\\s*(%|(?:[mM]|[kK]|[gG])?[bB])?\\s*$/);\n  if (!matches) {\n    return NaN;\n  }\n\n  const baselineBytes = (baseline && calculateBytes(baseline)) || 0;\n\n  let value = Number(matches[1]);\n  switch (matches[2] && matches[2].toLowerCase()) {\n    case '%':\n      value = (baselineBytes * value) / 100;\n      break;\n    case 'kb':\n      value *= 1024;\n      break;\n    case 'mb':\n      value *= 1024 * 1024;\n      break;\n    case 'gb':\n      value *= 1024 * 1024 * 1024;\n      break;\n  }\n\n  if (baselineBytes === 0) {\n    return value;\n  }\n\n  return baselineBytes + value * factor;\n}\n\nexport function* checkBudgets(\n  budgets: Budget[],\n  webpackStats: StatsCompilation,\n): IterableIterator<BudgetCalculatorResult> {\n  // Ignore AnyComponentStyle budgets as these are handled in `AnyComponentStyleBudgetChecker`.\n  const computableBudgets = budgets.filter((budget) => budget.type !== Type.AnyComponentStyle);\n\n  for (const budget of computableBudgets) {\n    const sizes = calculateSizes(budget, webpackStats);\n    for (const { size, label } of sizes) {\n      yield* checkThresholds(calculateThresholds(budget), size, label);\n    }\n  }\n}\n\nexport function* checkThresholds(\n  thresholds: IterableIterator<Threshold>,\n  size: number,\n  label?: string,\n): IterableIterator<BudgetCalculatorResult> {\n  for (const threshold of thresholds) {\n    switch (threshold.type) {\n      case ThresholdType.Max: {\n        if (size <= threshold.limit) {\n          continue;\n        }\n\n        const sizeDifference = formatSize(size - threshold.limit);\n        yield {\n          severity: threshold.severity,\n          label,\n          message: `${label} exceeded maximum budget. Budget ${formatSize(\n            threshold.limit,\n          )} was not met by ${sizeDifference} with a total of ${formatSize(size)}.`,\n        };\n        break;\n      }\n      case ThresholdType.Min: {\n        if (size >= threshold.limit) {\n          continue;\n        }\n\n        const sizeDifference = formatSize(threshold.limit - size);\n        yield {\n          severity: threshold.severity,\n          label,\n          message: `${label} failed to meet minimum budget. Budget ${formatSize(\n            threshold.limit,\n          )} was not met by ${sizeDifference} with a total of ${formatSize(size)}.`,\n        };\n        break;\n      }\n      default: {\n        throw new Error(`Unexpected threshold type: ${ThresholdType[threshold.type]}`);\n      }\n    }\n  }\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/utils/bundle-inline-options.d.ts b/artifacts/build-angular/src/utils/bundle-inline-options.d.ts new file mode 100644 index 00000000..96c9ae6b --- /dev/null +++ b/artifacts/build-angular/src/utils/bundle-inline-options.d.ts @@ -0,0 +1,15 @@ +/** + * @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 + */ +export interface InlineOptions { + filename: string; + code: string; + map?: string; + outputPath: string; + missingTranslation?: 'warning' | 'error' | 'ignore'; + setLocale?: boolean; +} diff --git a/artifacts/build-angular/src/utils/bundle-inline-options.js b/artifacts/build-angular/src/utils/bundle-inline-options.js new file mode 100644 index 00000000..1c8481e7 --- /dev/null +++ b/artifacts/build-angular/src/utils/bundle-inline-options.js @@ -0,0 +1,10 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVuZGxlLWlubGluZS1vcHRpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvYW5ndWxhcl9kZXZraXQvYnVpbGRfYW5ndWxhci9zcmMvdXRpbHMvYnVuZGxlLWlubGluZS1vcHRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7O0dBTUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuZXhwb3J0IGludGVyZmFjZSBJbmxpbmVPcHRpb25zIHtcbiAgZmlsZW5hbWU6IHN0cmluZztcbiAgY29kZTogc3RyaW5nO1xuICBtYXA/OiBzdHJpbmc7XG4gIG91dHB1dFBhdGg6IHN0cmluZztcbiAgbWlzc2luZ1RyYW5zbGF0aW9uPzogJ3dhcm5pbmcnIHwgJ2Vycm9yJyB8ICdpZ25vcmUnO1xuICBzZXRMb2NhbGU/OiBib29sZWFuO1xufVxuIl19 \ No newline at end of file diff --git a/artifacts/build-angular/src/utils/check-port.d.ts b/artifacts/build-angular/src/utils/check-port.d.ts new file mode 100644 index 00000000..3d7f05ae --- /dev/null +++ b/artifacts/build-angular/src/utils/check-port.d.ts @@ -0,0 +1,8 @@ +/** + * @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 + */ +export declare function checkPort(port: number, host: string): Promise; diff --git a/artifacts/build-angular/src/utils/check-port.js b/artifacts/build-angular/src/utils/check-port.js new file mode 100644 index 00000000..00903bc7 --- /dev/null +++ b/artifacts/build-angular/src/utils/check-port.js @@ -0,0 +1,71 @@ +"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.checkPort = void 0; +const net = __importStar(require("net")); +const tty_1 = require("./tty"); +function createInUseError(port) { + return new Error(`Port ${port} is already in use. Use '--port' to specify a different port.`); +} +async function checkPort(port, host) { + if (port === 0) { + return 0; + } + return new Promise((resolve, reject) => { + const server = net.createServer(); + server + .once('error', (err) => { + if (err.code !== 'EADDRINUSE') { + reject(err); + return; + } + if (!tty_1.isTTY) { + reject(createInUseError(port)); + return; + } + Promise.resolve().then(() => __importStar(require('inquirer'))).then(({ prompt }) => prompt({ + type: 'confirm', + name: 'useDifferent', + message: `Port ${port} is already in use.\nWould you like to use a different port?`, + default: true, + })) + .then((answers) => (answers.useDifferent ? resolve(0) : reject(createInUseError(port))), () => reject(createInUseError(port))); + }) + .once('listening', () => { + server.close(); + resolve(port); + }) + .listen(port, host); + }); +} +exports.checkPort = checkPort; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/utils/color.d.ts b/artifacts/build-angular/src/utils/color.d.ts new file mode 100644 index 00000000..b9aa88ac --- /dev/null +++ b/artifacts/build-angular/src/utils/color.d.ts @@ -0,0 +1,11 @@ +/** + * @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 * as ansiColors from 'ansi-colors'; +export declare function removeColor(text: string): string; +declare const colors: typeof ansiColors; +export { colors }; diff --git a/artifacts/build-angular/src/utils/color.js b/artifacts/build-angular/src/utils/color.js new file mode 100644 index 00000000..98912fb9 --- /dev/null +++ b/artifacts/build-angular/src/utils/color.js @@ -0,0 +1,70 @@ +"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.colors = exports.removeColor = void 0; +const ansiColors = __importStar(require("ansi-colors")); +const tty_1 = require("tty"); +function supportColor() { + if (process.env.FORCE_COLOR !== undefined) { + // 2 colors: FORCE_COLOR = 0 (Disables colors), depth 1 + // 16 colors: FORCE_COLOR = 1, depth 4 + // 256 colors: FORCE_COLOR = 2, depth 8 + // 16,777,216 colors: FORCE_COLOR = 3, depth 16 + // See: https://nodejs.org/dist/latest-v12.x/docs/api/tty.html#tty_writestream_getcolordepth_env + // and https://github.com/nodejs/node/blob/b9f36062d7b5c5039498e98d2f2c180dca2a7065/lib/internal/tty.js#L106; + switch (process.env.FORCE_COLOR) { + case '': + case 'true': + case '1': + case '2': + case '3': + return true; + default: + return false; + } + } + if (process.stdout instanceof tty_1.WriteStream) { + return process.stdout.getColorDepth() > 1; + } + return false; +} +function removeColor(text) { + // This has been created because when colors.enabled is false unstyle doesn't work + // see: https://github.com/doowb/ansi-colors/blob/a4794363369d7b4d1872d248fc43a12761640d8e/index.js#L38 + return text.replace(ansiColors.ansiRegex, ''); +} +exports.removeColor = removeColor; +// Create a separate instance to prevent unintended global changes to the color configuration +const colors = ansiColors.create(); +exports.colors = colors; +colors.enabled = supportColor(); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9hbmd1bGFyX2RldmtpdC9idWlsZF9hbmd1bGFyL3NyYy91dGlscy9jb2xvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7OztHQU1HOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUVILHdEQUEwQztBQUMxQyw2QkFBa0M7QUFFbEMsU0FBUyxZQUFZO0lBQ25CLElBQUksT0FBTyxDQUFDLEdBQUcsQ0FBQyxXQUFXLEtBQUssU0FBUyxFQUFFO1FBQ3pDLHVEQUF1RDtRQUN2RCxzQ0FBc0M7UUFDdEMsdUNBQXVDO1FBQ3ZDLCtDQUErQztRQUMvQyxnR0FBZ0c7UUFDaEcsNkdBQTZHO1FBQzdHLFFBQVEsT0FBTyxDQUFDLEdBQUcsQ0FBQyxXQUFXLEVBQUU7WUFDL0IsS0FBSyxFQUFFLENBQUM7WUFDUixLQUFLLE1BQU0sQ0FBQztZQUNaLEtBQUssR0FBRyxDQUFDO1lBQ1QsS0FBSyxHQUFHLENBQUM7WUFDVCxLQUFLLEdBQUc7Z0JBQ04sT0FBTyxJQUFJLENBQUM7WUFDZDtnQkFDRSxPQUFPLEtBQUssQ0FBQztTQUNoQjtLQUNGO0lBRUQsSUFBSSxPQUFPLENBQUMsTUFBTSxZQUFZLGlCQUFXLEVBQUU7UUFDekMsT0FBTyxPQUFPLENBQUMsTUFBTSxDQUFDLGFBQWEsRUFBRSxHQUFHLENBQUMsQ0FBQztLQUMzQztJQUVELE9BQU8sS0FBSyxDQUFDO0FBQ2YsQ0FBQztBQUVELFNBQWdCLFdBQVcsQ0FBQyxJQUFZO0lBQ3RDLGtGQUFrRjtJQUNsRix1R0FBdUc7SUFDdkcsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxTQUFTLEVBQUUsRUFBRSxDQUFDLENBQUM7QUFDaEQsQ0FBQztBQUpELGtDQUlDO0FBRUQsNkZBQTZGO0FBQzdGLE1BQU0sTUFBTSxHQUFHLFVBQVUsQ0FBQyxNQUFNLEVBQUUsQ0FBQztBQUcxQix3QkFBTTtBQUZmLE1BQU0sQ0FBQyxPQUFPLEdBQUcsWUFBWSxFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0ICogYXMgYW5zaUNvbG9ycyBmcm9tICdhbnNpLWNvbG9ycyc7XG5pbXBvcnQgeyBXcml0ZVN0cmVhbSB9IGZyb20gJ3R0eSc7XG5cbmZ1bmN0aW9uIHN1cHBvcnRDb2xvcigpOiBib29sZWFuIHtcbiAgaWYgKHByb2Nlc3MuZW52LkZPUkNFX0NPTE9SICE9PSB1bmRlZmluZWQpIHtcbiAgICAvLyAyIGNvbG9yczogRk9SQ0VfQ09MT1IgPSAwIChEaXNhYmxlcyBjb2xvcnMpLCBkZXB0aCAxXG4gICAgLy8gMTYgY29sb3JzOiBGT1JDRV9DT0xPUiA9IDEsIGRlcHRoIDRcbiAgICAvLyAyNTYgY29sb3JzOiBGT1JDRV9DT0xPUiA9IDIsIGRlcHRoIDhcbiAgICAvLyAxNiw3NzcsMjE2IGNvbG9yczogRk9SQ0VfQ09MT1IgPSAzLCBkZXB0aCAxNlxuICAgIC8vIFNlZTogaHR0cHM6Ly9ub2RlanMub3JnL2Rpc3QvbGF0ZXN0LXYxMi54L2RvY3MvYXBpL3R0eS5odG1sI3R0eV93cml0ZXN0cmVhbV9nZXRjb2xvcmRlcHRoX2VudlxuICAgIC8vIGFuZCBodHRwczovL2dpdGh1Yi5jb20vbm9kZWpzL25vZGUvYmxvYi9iOWYzNjA2MmQ3YjVjNTAzOTQ5OGU5OGQyZjJjMTgwZGNhMmE3MDY1L2xpYi9pbnRlcm5hbC90dHkuanMjTDEwNjtcbiAgICBzd2l0Y2ggKHByb2Nlc3MuZW52LkZPUkNFX0NPTE9SKSB7XG4gICAgICBjYXNlICcnOlxuICAgICAgY2FzZSAndHJ1ZSc6XG4gICAgICBjYXNlICcxJzpcbiAgICAgIGNhc2UgJzInOlxuICAgICAgY2FzZSAnMyc6XG4gICAgICAgIHJldHVybiB0cnVlO1xuICAgICAgZGVmYXVsdDpcbiAgICAgICAgcmV0dXJuIGZhbHNlO1xuICAgIH1cbiAgfVxuXG4gIGlmIChwcm9jZXNzLnN0ZG91dCBpbnN0YW5jZW9mIFdyaXRlU3RyZWFtKSB7XG4gICAgcmV0dXJuIHByb2Nlc3Muc3Rkb3V0LmdldENvbG9yRGVwdGgoKSA+IDE7XG4gIH1cblxuICByZXR1cm4gZmFsc2U7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiByZW1vdmVDb2xvcih0ZXh0OiBzdHJpbmcpOiBzdHJpbmcge1xuICAvLyBUaGlzIGhhcyBiZWVuIGNyZWF0ZWQgYmVjYXVzZSB3aGVuIGNvbG9ycy5lbmFibGVkIGlzIGZhbHNlIHVuc3R5bGUgZG9lc24ndCB3b3JrXG4gIC8vIHNlZTogaHR0cHM6Ly9naXRodWIuY29tL2Rvb3diL2Fuc2ktY29sb3JzL2Jsb2IvYTQ3OTQzNjMzNjlkN2I0ZDE4NzJkMjQ4ZmM0M2ExMjc2MTY0MGQ4ZS9pbmRleC5qcyNMMzhcbiAgcmV0dXJuIHRleHQucmVwbGFjZShhbnNpQ29sb3JzLmFuc2lSZWdleCwgJycpO1xufVxuXG4vLyBDcmVhdGUgYSBzZXBhcmF0ZSBpbnN0YW5jZSB0byBwcmV2ZW50IHVuaW50ZW5kZWQgZ2xvYmFsIGNoYW5nZXMgdG8gdGhlIGNvbG9yIGNvbmZpZ3VyYXRpb25cbmNvbnN0IGNvbG9ycyA9IGFuc2lDb2xvcnMuY3JlYXRlKCk7XG5jb2xvcnMuZW5hYmxlZCA9IHN1cHBvcnRDb2xvcigpO1xuXG5leHBvcnQgeyBjb2xvcnMgfTtcbiJdfQ== \ No newline at end of file diff --git a/artifacts/build-angular/src/utils/copy-assets.d.ts b/artifacts/build-angular/src/utils/copy-assets.d.ts new file mode 100644 index 00000000..44130f5d --- /dev/null +++ b/artifacts/build-angular/src/utils/copy-assets.d.ts @@ -0,0 +1,18 @@ +/** + * @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 + */ +export declare function copyAssets(entries: { + glob: string; + ignore?: string[]; + input: string; + output: string; + flatten?: boolean; + followSymlinks?: boolean; +}[], basePaths: Iterable, root: string, changed?: Set): Promise<{ + source: string; + destination: string; +}[]>; diff --git a/artifacts/build-angular/src/utils/copy-assets.js b/artifacts/build-angular/src/utils/copy-assets.js new file mode 100644 index 00000000..3f472827 --- /dev/null +++ b/artifacts/build-angular/src/utils/copy-assets.js @@ -0,0 +1,80 @@ +"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; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.copyAssets = void 0; +const fs = __importStar(require("fs")); +const glob_1 = __importDefault(require("glob")); +const path = __importStar(require("path")); +const util_1 = require("util"); +const globPromise = (0, util_1.promisify)(glob_1.default); +async function copyAssets(entries, basePaths, root, changed) { + const defaultIgnore = ['.gitkeep', '**/.DS_Store', '**/Thumbs.db']; + const outputFiles = []; + for (const entry of entries) { + const cwd = path.resolve(root, entry.input); + const files = await globPromise(entry.glob, { + cwd, + dot: true, + nodir: true, + root: cwd, + nomount: true, + ignore: entry.ignore ? defaultIgnore.concat(entry.ignore) : defaultIgnore, + follow: entry.followSymlinks, + }); + const directoryExists = new Set(); + for (const file of files) { + const src = path.join(cwd, file); + if (changed && !changed.has(src)) { + continue; + } + const filePath = entry.flatten ? path.basename(file) : file; + outputFiles.push({ source: src, destination: path.join(entry.output, filePath) }); + for (const base of basePaths) { + const dest = path.join(base, entry.output, filePath); + const dir = path.dirname(dest); + if (!directoryExists.has(dir)) { + if (!fs.existsSync(dir)) { + fs.mkdirSync(dir, { recursive: true }); + } + directoryExists.add(dir); + } + fs.copyFileSync(src, dest, fs.constants.COPYFILE_FICLONE); + } + } + } + return outputFiles; +} +exports.copyAssets = copyAssets; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/utils/default-progress.d.ts b/artifacts/build-angular/src/utils/default-progress.d.ts new file mode 100644 index 00000000..80bc5973 --- /dev/null +++ b/artifacts/build-angular/src/utils/default-progress.d.ts @@ -0,0 +1,8 @@ +/** + * @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 + */ +export declare function defaultProgress(progress: boolean | undefined): boolean; diff --git a/artifacts/build-angular/src/utils/default-progress.js b/artifacts/build-angular/src/utils/default-progress.js new file mode 100644 index 00000000..8641b926 --- /dev/null +++ b/artifacts/build-angular/src/utils/default-progress.js @@ -0,0 +1,18 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.defaultProgress = void 0; +function defaultProgress(progress) { + if (progress === undefined) { + return process.stdout.isTTY === true; + } + return progress; +} +exports.defaultProgress = defaultProgress; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC1wcm9ncmVzcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2FuZ3VsYXJfZGV2a2l0L2J1aWxkX2FuZ3VsYXIvc3JjL3V0aWxzL2RlZmF1bHQtcHJvZ3Jlc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7R0FNRzs7O0FBRUgsU0FBZ0IsZUFBZSxDQUFDLFFBQTZCO0lBQzNELElBQUksUUFBUSxLQUFLLFNBQVMsRUFBRTtRQUMxQixPQUFPLE9BQU8sQ0FBQyxNQUFNLENBQUMsS0FBSyxLQUFLLElBQUksQ0FBQztLQUN0QztJQUVELE9BQU8sUUFBUSxDQUFDO0FBQ2xCLENBQUM7QUFORCwwQ0FNQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQgZnVuY3Rpb24gZGVmYXVsdFByb2dyZXNzKHByb2dyZXNzOiBib29sZWFuIHwgdW5kZWZpbmVkKTogYm9vbGVhbiB7XG4gIGlmIChwcm9ncmVzcyA9PT0gdW5kZWZpbmVkKSB7XG4gICAgcmV0dXJuIHByb2Nlc3Muc3Rkb3V0LmlzVFRZID09PSB0cnVlO1xuICB9XG5cbiAgcmV0dXJuIHByb2dyZXNzO1xufVxuIl19 \ No newline at end of file diff --git a/artifacts/build-angular/src/utils/delete-output-dir.d.ts b/artifacts/build-angular/src/utils/delete-output-dir.d.ts new file mode 100644 index 00000000..2affb275 --- /dev/null +++ b/artifacts/build-angular/src/utils/delete-output-dir.d.ts @@ -0,0 +1,11 @@ +/** + * @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 + */ +/** + * Delete an output directory, but error out if it's the root of the project. + */ +export declare function deleteOutputDir(root: string, outputPath: string): void; diff --git a/artifacts/build-angular/src/utils/delete-output-dir.js b/artifacts/build-angular/src/utils/delete-output-dir.js new file mode 100644 index 00000000..1286fe71 --- /dev/null +++ b/artifacts/build-angular/src/utils/delete-output-dir.js @@ -0,0 +1,47 @@ +"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.deleteOutputDir = void 0; +const fs = __importStar(require("fs")); +const path_1 = require("path"); +/** + * Delete an output directory, but error out if it's the root of the project. + */ +function deleteOutputDir(root, outputPath) { + const resolvedOutputPath = (0, path_1.resolve)(root, outputPath); + if (resolvedOutputPath === root) { + throw new Error('Output path MUST not be project root directory!'); + } + fs.rmSync(resolvedOutputPath, { force: true, recursive: true, maxRetries: 3 }); +} +exports.deleteOutputDir = deleteOutputDir; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVsZXRlLW91dHB1dC1kaXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9hbmd1bGFyX2RldmtpdC9idWlsZF9hbmd1bGFyL3NyYy91dGlscy9kZWxldGUtb3V0cHV0LWRpci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7OztHQU1HOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUVILHVDQUF5QjtBQUN6QiwrQkFBK0I7QUFFL0I7O0dBRUc7QUFDSCxTQUFnQixlQUFlLENBQUMsSUFBWSxFQUFFLFVBQWtCO0lBQzlELE1BQU0sa0JBQWtCLEdBQUcsSUFBQSxjQUFPLEVBQUMsSUFBSSxFQUFFLFVBQVUsQ0FBQyxDQUFDO0lBQ3JELElBQUksa0JBQWtCLEtBQUssSUFBSSxFQUFFO1FBQy9CLE1BQU0sSUFBSSxLQUFLLENBQUMsaURBQWlELENBQUMsQ0FBQztLQUNwRTtJQUVELEVBQUUsQ0FBQyxNQUFNLENBQUMsa0JBQWtCLEVBQUUsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLFNBQVMsRUFBRSxJQUFJLEVBQUUsVUFBVSxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUM7QUFDakYsQ0FBQztBQVBELDBDQU9DIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCAqIGFzIGZzIGZyb20gJ2ZzJztcbmltcG9ydCB7IHJlc29sdmUgfSBmcm9tICdwYXRoJztcblxuLyoqXG4gKiBEZWxldGUgYW4gb3V0cHV0IGRpcmVjdG9yeSwgYnV0IGVycm9yIG91dCBpZiBpdCdzIHRoZSByb290IG9mIHRoZSBwcm9qZWN0LlxuICovXG5leHBvcnQgZnVuY3Rpb24gZGVsZXRlT3V0cHV0RGlyKHJvb3Q6IHN0cmluZywgb3V0cHV0UGF0aDogc3RyaW5nKTogdm9pZCB7XG4gIGNvbnN0IHJlc29sdmVkT3V0cHV0UGF0aCA9IHJlc29sdmUocm9vdCwgb3V0cHV0UGF0aCk7XG4gIGlmIChyZXNvbHZlZE91dHB1dFBhdGggPT09IHJvb3QpIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoJ091dHB1dCBwYXRoIE1VU1Qgbm90IGJlIHByb2plY3Qgcm9vdCBkaXJlY3RvcnkhJyk7XG4gIH1cblxuICBmcy5ybVN5bmMocmVzb2x2ZWRPdXRwdXRQYXRoLCB7IGZvcmNlOiB0cnVlLCByZWN1cnNpdmU6IHRydWUsIG1heFJldHJpZXM6IDMgfSk7XG59XG4iXX0= \ No newline at end of file diff --git a/artifacts/build-angular/src/utils/environment-options.d.ts b/artifacts/build-angular/src/utils/environment-options.d.ts new file mode 100644 index 00000000..c959cf72 --- /dev/null +++ b/artifacts/build-angular/src/utils/environment-options.d.ts @@ -0,0 +1,13 @@ +/** + * @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 + */ +export declare const allowMangle: boolean; +export declare const shouldBeautify: boolean; +export declare const allowMinify: boolean; +export declare const maxWorkers: number; +export declare const useLegacySass: boolean; +export declare const debugPerformance: boolean; diff --git a/artifacts/build-angular/src/utils/environment-options.js b/artifacts/build-angular/src/utils/environment-options.js new file mode 100644 index 00000000..0cc6d8cf --- /dev/null +++ b/artifacts/build-angular/src/utils/environment-options.js @@ -0,0 +1,82 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.debugPerformance = exports.useLegacySass = exports.maxWorkers = exports.allowMinify = exports.shouldBeautify = exports.allowMangle = void 0; +const color_1 = require("./color"); +function isDisabled(variable) { + return variable === '0' || variable.toLowerCase() === 'false'; +} +function isEnabled(variable) { + return variable === '1' || variable.toLowerCase() === 'true'; +} +function isPresent(variable) { + return typeof variable === 'string' && variable !== ''; +} +// Optimization and mangling +const debugOptimizeVariable = process.env['NG_BUILD_DEBUG_OPTIMIZE']; +const debugOptimize = (() => { + if (!isPresent(debugOptimizeVariable) || isDisabled(debugOptimizeVariable)) { + return { + mangle: true, + minify: true, + beautify: false, + }; + } + const debugValue = { + mangle: false, + minify: false, + beautify: true, + }; + if (isEnabled(debugOptimizeVariable)) { + return debugValue; + } + for (const part of debugOptimizeVariable.split(',')) { + switch (part.trim().toLowerCase()) { + case 'mangle': + debugValue.mangle = true; + break; + case 'minify': + debugValue.minify = true; + break; + case 'beautify': + debugValue.beautify = true; + break; + } + } + return debugValue; +})(); +const mangleVariable = process.env['NG_BUILD_MANGLE']; +exports.allowMangle = isPresent(mangleVariable) + ? !isDisabled(mangleVariable) + : debugOptimize.mangle; +exports.shouldBeautify = debugOptimize.beautify; +exports.allowMinify = debugOptimize.minify; +/** + * Some environments, like CircleCI which use Docker report a number of CPUs by the host and not the count of available. + * This cause `Error: Call retries were exceeded` errors when trying to use them. + * + * @see https://github.com/nodejs/node/issues/28762 + * @see https://github.com/webpack-contrib/terser-webpack-plugin/issues/143 + * @see https://ithub.com/angular/angular-cli/issues/16860#issuecomment-588828079 + * + */ +const maxWorkersVariable = process.env['NG_BUILD_MAX_WORKERS']; +exports.maxWorkers = isPresent(maxWorkersVariable) ? +maxWorkersVariable : 4; +const legacySassVariable = process.env['NG_BUILD_LEGACY_SASS']; +exports.useLegacySass = (() => { + if (!isPresent(legacySassVariable)) { + return false; + } + // eslint-disable-next-line no-console + console.warn(color_1.colors.yellow(`Warning: 'NG_BUILD_LEGACY_SASS' environment variable support will be removed in version 16.`)); + return isEnabled(legacySassVariable); +})(); +const debugPerfVariable = process.env['NG_BUILD_DEBUG_PERF']; +exports.debugPerformance = isPresent(debugPerfVariable) && isEnabled(debugPerfVariable); +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/utils/error.d.ts b/artifacts/build-angular/src/utils/error.d.ts new file mode 100644 index 00000000..14755d07 --- /dev/null +++ b/artifacts/build-angular/src/utils/error.d.ts @@ -0,0 +1,10 @@ +/** + * @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 + */ +export declare function assertIsError(value: unknown): asserts value is Error & { + code?: string; +}; diff --git a/artifacts/build-angular/src/utils/error.js b/artifacts/build-angular/src/utils/error.js new file mode 100644 index 00000000..c581cffb --- /dev/null +++ b/artifacts/build-angular/src/utils/error.js @@ -0,0 +1,22 @@ +"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 __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.assertIsError = void 0; +const assert_1 = __importDefault(require("assert")); +function assertIsError(value) { + const isError = value instanceof Error || + // The following is needing to identify errors coming from RxJs. + (typeof value === 'object' && value && 'name' in value && 'message' in value); + (0, assert_1.default)(isError, 'catch clause variable is not an Error instance'); +} +exports.assertIsError = assertIsError; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9hbmd1bGFyX2RldmtpdC9idWlsZF9hbmd1bGFyL3NyYy91dGlscy9lcnJvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7OztHQU1HOzs7Ozs7QUFFSCxvREFBNEI7QUFFNUIsU0FBZ0IsYUFBYSxDQUFDLEtBQWM7SUFDMUMsTUFBTSxPQUFPLEdBQ1gsS0FBSyxZQUFZLEtBQUs7UUFDdEIsZ0VBQWdFO1FBQ2hFLENBQUMsT0FBTyxLQUFLLEtBQUssUUFBUSxJQUFJLEtBQUssSUFBSSxNQUFNLElBQUksS0FBSyxJQUFJLFNBQVMsSUFBSSxLQUFLLENBQUMsQ0FBQztJQUNoRixJQUFBLGdCQUFNLEVBQUMsT0FBTyxFQUFFLGdEQUFnRCxDQUFDLENBQUM7QUFDcEUsQ0FBQztBQU5ELHNDQU1DIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCBhc3NlcnQgZnJvbSAnYXNzZXJ0JztcblxuZXhwb3J0IGZ1bmN0aW9uIGFzc2VydElzRXJyb3IodmFsdWU6IHVua25vd24pOiBhc3NlcnRzIHZhbHVlIGlzIEVycm9yICYgeyBjb2RlPzogc3RyaW5nIH0ge1xuICBjb25zdCBpc0Vycm9yID1cbiAgICB2YWx1ZSBpbnN0YW5jZW9mIEVycm9yIHx8XG4gICAgLy8gVGhlIGZvbGxvd2luZyBpcyBuZWVkaW5nIHRvIGlkZW50aWZ5IGVycm9ycyBjb21pbmcgZnJvbSBSeEpzLlxuICAgICh0eXBlb2YgdmFsdWUgPT09ICdvYmplY3QnICYmIHZhbHVlICYmICduYW1lJyBpbiB2YWx1ZSAmJiAnbWVzc2FnZScgaW4gdmFsdWUpO1xuICBhc3NlcnQoaXNFcnJvciwgJ2NhdGNoIGNsYXVzZSB2YXJpYWJsZSBpcyBub3QgYW4gRXJyb3IgaW5zdGFuY2UnKTtcbn1cbiJdfQ== \ No newline at end of file diff --git a/artifacts/build-angular/src/utils/esbuild-targets.d.ts b/artifacts/build-angular/src/utils/esbuild-targets.d.ts new file mode 100644 index 00000000..cb17bc13 --- /dev/null +++ b/artifacts/build-angular/src/utils/esbuild-targets.d.ts @@ -0,0 +1,12 @@ +/** + * @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 + */ +/** + * Transform browserlists result to esbuild target. + * @see https://esbuild.github.io/api/#target + */ +export declare function transformSupportedBrowsersToTargets(supportedBrowsers: string[]): string[]; diff --git a/artifacts/build-angular/src/utils/esbuild-targets.js b/artifacts/build-angular/src/utils/esbuild-targets.js new file mode 100644 index 00000000..4983cf41 --- /dev/null +++ b/artifacts/build-angular/src/utils/esbuild-targets.js @@ -0,0 +1,55 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.transformSupportedBrowsersToTargets = void 0; +/** + * Transform browserlists result to esbuild target. + * @see https://esbuild.github.io/api/#target + */ +function transformSupportedBrowsersToTargets(supportedBrowsers) { + const transformed = []; + // https://esbuild.github.io/api/#target + const esBuildSupportedBrowsers = new Set([ + 'chrome', + 'edge', + 'firefox', + 'ie', + 'ios', + 'node', + 'opera', + 'safari', + ]); + for (const browser of supportedBrowsers) { + let [browserName, version] = browser.toLowerCase().split(' '); + // browserslist uses the name `ios_saf` for iOS Safari whereas esbuild uses `ios` + if (browserName === 'ios_saf') { + browserName = 'ios'; + } + // browserslist uses ranges `15.2-15.3` versions but only the lowest is required + // to perform minimum supported feature checks. esbuild also expects a single version. + [version] = version.split('-'); + if (esBuildSupportedBrowsers.has(browserName)) { + if (browserName === 'safari' && version === 'tp') { + // esbuild only supports numeric versions so `TP` is converted to a high number (999) since + // a Technology Preview (TP) of Safari is assumed to support all currently known features. + version = '999'; + } + else if (!version.includes('.')) { + // A lone major version is considered by esbuild to include all minor versions. However, + // browserslist does not and is also inconsistent in its `.0` version naming. For example, + // Safari 15.0 is named `safari 15` but Safari 16.0 is named `safari 16.0`. + version += '.0'; + } + transformed.push(browserName + version); + } + } + return transformed; +} +exports.transformSupportedBrowsersToTargets = transformSupportedBrowsersToTargets; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/utils/i18n-inlining.d.ts b/artifacts/build-angular/src/utils/i18n-inlining.d.ts new file mode 100644 index 00000000..9efffb61 --- /dev/null +++ b/artifacts/build-angular/src/utils/i18n-inlining.d.ts @@ -0,0 +1,11 @@ +/** + * @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 { EmittedFiles } from '@angular-devkit/build-webpack'; +import { I18nOptions } from './i18n-options'; +export declare function i18nInlineEmittedFiles(context: BuilderContext, emittedFiles: EmittedFiles[], i18n: I18nOptions, baseOutputPath: string, outputPaths: string[], scriptsEntryPointName: string[], emittedPath: string, missingTranslation: 'error' | 'warning' | 'ignore' | undefined): Promise; diff --git a/artifacts/build-angular/src/utils/i18n-inlining.js b/artifacts/build-angular/src/utils/i18n-inlining.js new file mode 100644 index 00000000..8b42f3bc --- /dev/null +++ b/artifacts/build-angular/src/utils/i18n-inlining.js @@ -0,0 +1,122 @@ +"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.i18nInlineEmittedFiles = void 0; +const fs = __importStar(require("fs")); +const path = __importStar(require("path")); +const action_executor_1 = require("./action-executor"); +const copy_assets_1 = require("./copy-assets"); +const error_1 = require("./error"); +const spinner_1 = require("./spinner"); +function emittedFilesToInlineOptions(emittedFiles, scriptsEntryPointName, emittedPath, outputPath, missingTranslation, context) { + const options = []; + const originalFiles = []; + for (const emittedFile of emittedFiles) { + if (emittedFile.asset || + emittedFile.extension !== '.js' || + (emittedFile.name && scriptsEntryPointName.includes(emittedFile.name))) { + continue; + } + const originalPath = path.join(emittedPath, emittedFile.file); + const action = { + filename: emittedFile.file, + code: fs.readFileSync(originalPath, 'utf8'), + outputPath, + missingTranslation, + setLocale: emittedFile.name === 'main', + }; + originalFiles.push(originalPath); + try { + const originalMapPath = originalPath + '.map'; + action.map = fs.readFileSync(originalMapPath, 'utf8'); + originalFiles.push(originalMapPath); + } + catch (err) { + (0, error_1.assertIsError)(err); + if (err.code !== 'ENOENT') { + throw err; + } + } + context.logger.debug(`i18n file queued for processing: ${action.filename}`); + options.push(action); + } + return { options, originalFiles }; +} +async function i18nInlineEmittedFiles(context, emittedFiles, i18n, baseOutputPath, outputPaths, scriptsEntryPointName, emittedPath, missingTranslation) { + const executor = new action_executor_1.BundleActionExecutor({ i18n }); + let hasErrors = false; + const spinner = new spinner_1.Spinner(); + spinner.start('Generating localized bundles...'); + try { + const { options, originalFiles: processedFiles } = emittedFilesToInlineOptions(emittedFiles, scriptsEntryPointName, emittedPath, baseOutputPath, missingTranslation, context); + for await (const result of executor.inlineAll(options)) { + context.logger.debug(`i18n file processed: ${result.file}`); + for (const diagnostic of result.diagnostics) { + spinner.stop(); + if (diagnostic.type === 'error') { + hasErrors = true; + context.logger.error(diagnostic.message); + } + else { + context.logger.warn(diagnostic.message); + } + spinner.start(); + } + } + // Copy any non-processed files into the output locations + await (0, copy_assets_1.copyAssets)([ + { + glob: '**/*', + input: emittedPath, + output: '', + ignore: [...processedFiles].map((f) => path.relative(emittedPath, f)), + }, + ], outputPaths, ''); + } + catch (err) { + (0, error_1.assertIsError)(err); + spinner.fail('Localized bundle generation failed: ' + err.message); + return false; + } + finally { + executor.stop(); + } + if (hasErrors) { + spinner.fail('Localized bundle generation failed.'); + } + else { + spinner.succeed('Localized bundle generation complete.'); + } + return !hasErrors; +} +exports.i18nInlineEmittedFiles = i18nInlineEmittedFiles; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"i18n-inlining.js","sourceRoot":"","sources":["../../../../../../../../packages/angular_devkit/build_angular/src/utils/i18n-inlining.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 { BuilderContext } from '@angular-devkit/architect';\nimport { EmittedFiles } from '@angular-devkit/build-webpack';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { BundleActionExecutor } from './action-executor';\nimport { InlineOptions } from './bundle-inline-options';\nimport { copyAssets } from './copy-assets';\nimport { assertIsError } from './error';\nimport { I18nOptions } from './i18n-options';\nimport { Spinner } from './spinner';\n\nfunction emittedFilesToInlineOptions(\n  emittedFiles: EmittedFiles[],\n  scriptsEntryPointName: string[],\n  emittedPath: string,\n  outputPath: string,\n  missingTranslation: 'error' | 'warning' | 'ignore' | undefined,\n  context: BuilderContext,\n): { options: InlineOptions[]; originalFiles: string[] } {\n  const options: InlineOptions[] = [];\n  const originalFiles: string[] = [];\n  for (const emittedFile of emittedFiles) {\n    if (\n      emittedFile.asset ||\n      emittedFile.extension !== '.js' ||\n      (emittedFile.name && scriptsEntryPointName.includes(emittedFile.name))\n    ) {\n      continue;\n    }\n\n    const originalPath = path.join(emittedPath, emittedFile.file);\n    const action: InlineOptions = {\n      filename: emittedFile.file,\n      code: fs.readFileSync(originalPath, 'utf8'),\n      outputPath,\n      missingTranslation,\n      setLocale: emittedFile.name === 'main',\n    };\n    originalFiles.push(originalPath);\n\n    try {\n      const originalMapPath = originalPath + '.map';\n      action.map = fs.readFileSync(originalMapPath, 'utf8');\n      originalFiles.push(originalMapPath);\n    } catch (err) {\n      assertIsError(err);\n      if (err.code !== 'ENOENT') {\n        throw err;\n      }\n    }\n\n    context.logger.debug(`i18n file queued for processing: ${action.filename}`);\n\n    options.push(action);\n  }\n\n  return { options, originalFiles };\n}\n\nexport async function i18nInlineEmittedFiles(\n  context: BuilderContext,\n  emittedFiles: EmittedFiles[],\n  i18n: I18nOptions,\n  baseOutputPath: string,\n  outputPaths: string[],\n  scriptsEntryPointName: string[],\n  emittedPath: string,\n  missingTranslation: 'error' | 'warning' | 'ignore' | undefined,\n): Promise<boolean> {\n  const executor = new BundleActionExecutor({ i18n });\n  let hasErrors = false;\n  const spinner = new Spinner();\n  spinner.start('Generating localized bundles...');\n\n  try {\n    const { options, originalFiles: processedFiles } = emittedFilesToInlineOptions(\n      emittedFiles,\n      scriptsEntryPointName,\n      emittedPath,\n      baseOutputPath,\n      missingTranslation,\n      context,\n    );\n\n    for await (const result of executor.inlineAll(options)) {\n      context.logger.debug(`i18n file processed: ${result.file}`);\n\n      for (const diagnostic of result.diagnostics) {\n        spinner.stop();\n        if (diagnostic.type === 'error') {\n          hasErrors = true;\n          context.logger.error(diagnostic.message);\n        } else {\n          context.logger.warn(diagnostic.message);\n        }\n        spinner.start();\n      }\n    }\n\n    // Copy any non-processed files into the output locations\n    await copyAssets(\n      [\n        {\n          glob: '**/*',\n          input: emittedPath,\n          output: '',\n          ignore: [...processedFiles].map((f) => path.relative(emittedPath, f)),\n        },\n      ],\n      outputPaths,\n      '',\n    );\n  } catch (err) {\n    assertIsError(err);\n    spinner.fail('Localized bundle generation failed: ' + err.message);\n\n    return false;\n  } finally {\n    executor.stop();\n  }\n\n  if (hasErrors) {\n    spinner.fail('Localized bundle generation failed.');\n  } else {\n    spinner.succeed('Localized bundle generation complete.');\n  }\n\n  return !hasErrors;\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/utils/i18n-options.d.ts b/artifacts/build-angular/src/utils/i18n-options.d.ts new file mode 100644 index 00000000..288090c9 --- /dev/null +++ b/artifacts/build-angular/src/utils/i18n-options.d.ts @@ -0,0 +1,39 @@ +/** + * @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 { json } from '@angular-devkit/core'; +import { Schema as BrowserBuilderSchema, I18NTranslation } from '../builders/browser/schema'; +import { Schema as ServerBuilderSchema } from '../builders/server/schema'; +import { TranslationLoader } from './load-translations'; +export interface LocaleDescription { + files: { + path: string; + integrity?: string; + format?: string; + }[]; + translation?: Record; + dataPath?: string; + baseHref?: string; +} +export interface I18nOptions { + inlineLocales: Set; + sourceLocale: string; + locales: Record; + flatOutput?: boolean; + readonly shouldInline: boolean; + hasDefinedSourceLocale?: boolean; +} +export declare function createI18nOptions(metadata: json.JsonObject, inline?: boolean | string[]): I18nOptions; +export declare function configureI18nBuild(context: BuilderContext, options: T): Promise<{ + buildOptions: T; + i18n: I18nOptions; +}>; +export declare function loadTranslations(locale: string, desc: LocaleDescription, workspaceRoot: string, loader: TranslationLoader, logger: { + warn: (message: string) => void; + error: (message: string) => void; +}, usedFormats?: Set, duplicateTranslation?: I18NTranslation): void; diff --git a/artifacts/build-angular/src/utils/i18n-options.js b/artifacts/build-angular/src/utils/i18n-options.js new file mode 100644 index 00000000..0abaebc2 --- /dev/null +++ b/artifacts/build-angular/src/utils/i18n-options.js @@ -0,0 +1,249 @@ +"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 __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.loadTranslations = exports.configureI18nBuild = exports.createI18nOptions = void 0; +const core_1 = require("@angular-devkit/core"); +const fs_1 = __importDefault(require("fs")); +const module_1 = __importDefault(require("module")); +const os_1 = __importDefault(require("os")); +const path_1 = __importDefault(require("path")); +const schema_1 = require("../builders/browser/schema"); +const read_tsconfig_1 = require("../utils/read-tsconfig"); +const load_translations_1 = require("./load-translations"); +/** + * The base module location used to search for locale specific data. + */ +const LOCALE_DATA_BASE_MODULE = '@angular/common/locales/global'; +function normalizeTranslationFileOption(option, locale, expectObjectInError) { + if (typeof option === 'string') { + return [option]; + } + if (Array.isArray(option) && option.every((element) => typeof element === 'string')) { + return option; + } + let errorMessage = `Project i18n locales translation field value for '${locale}' is malformed. `; + if (expectObjectInError) { + errorMessage += 'Expected a string, array of strings, or object.'; + } + else { + errorMessage += 'Expected a string or array of strings.'; + } + throw new Error(errorMessage); +} +function createI18nOptions(metadata, inline) { + if (metadata.i18n !== undefined && !core_1.json.isJsonObject(metadata.i18n)) { + throw new Error('Project i18n field is malformed. Expected an object.'); + } + metadata = metadata.i18n || {}; + const i18n = { + inlineLocales: new Set(), + // en-US is the default locale added to Angular applications (https://angular.io/guide/i18n#i18n-pipes) + sourceLocale: 'en-US', + locales: {}, + get shouldInline() { + return this.inlineLocales.size > 0; + }, + }; + let rawSourceLocale; + let rawSourceLocaleBaseHref; + if (core_1.json.isJsonObject(metadata.sourceLocale)) { + rawSourceLocale = metadata.sourceLocale.code; + if (metadata.sourceLocale.baseHref !== undefined && + typeof metadata.sourceLocale.baseHref !== 'string') { + throw new Error('Project i18n sourceLocale baseHref field is malformed. Expected a string.'); + } + rawSourceLocaleBaseHref = metadata.sourceLocale.baseHref; + } + else { + rawSourceLocale = metadata.sourceLocale; + } + if (rawSourceLocale !== undefined) { + if (typeof rawSourceLocale !== 'string') { + throw new Error('Project i18n sourceLocale field is malformed. Expected a string.'); + } + i18n.sourceLocale = rawSourceLocale; + i18n.hasDefinedSourceLocale = true; + } + i18n.locales[i18n.sourceLocale] = { + files: [], + baseHref: rawSourceLocaleBaseHref, + }; + if (metadata.locales !== undefined && !core_1.json.isJsonObject(metadata.locales)) { + throw new Error('Project i18n locales field is malformed. Expected an object.'); + } + else if (metadata.locales) { + for (const [locale, options] of Object.entries(metadata.locales)) { + let translationFiles; + let baseHref; + if (core_1.json.isJsonObject(options)) { + translationFiles = normalizeTranslationFileOption(options.translation, locale, false); + if (typeof options.baseHref === 'string') { + baseHref = options.baseHref; + } + } + else { + translationFiles = normalizeTranslationFileOption(options, locale, true); + } + if (locale === i18n.sourceLocale) { + throw new Error(`An i18n locale ('${locale}') cannot both be a source locale and provide a translation.`); + } + i18n.locales[locale] = { + files: translationFiles.map((file) => ({ path: file })), + baseHref, + }; + } + } + if (inline === true) { + i18n.inlineLocales.add(i18n.sourceLocale); + Object.keys(i18n.locales).forEach((locale) => i18n.inlineLocales.add(locale)); + } + else if (inline) { + for (const locale of inline) { + if (!i18n.locales[locale] && i18n.sourceLocale !== locale) { + throw new Error(`Requested locale '${locale}' is not defined for the project.`); + } + i18n.inlineLocales.add(locale); + } + } + return i18n; +} +exports.createI18nOptions = createI18nOptions; +async function configureI18nBuild(context, options) { + if (!context.target) { + throw new Error('The builder requires a target.'); + } + const buildOptions = { ...options }; + const tsConfig = await (0, read_tsconfig_1.readTsconfig)(buildOptions.tsConfig, context.workspaceRoot); + const metadata = await context.getProjectMetadata(context.target); + const i18n = createI18nOptions(metadata, buildOptions.localize); + // No additional processing needed if no inlining requested and no source locale defined. + if (!i18n.shouldInline && !i18n.hasDefinedSourceLocale) { + return { buildOptions, i18n }; + } + const projectRoot = path_1.default.join(context.workspaceRoot, metadata.root || ''); + // The trailing slash is required to signal that the path is a directory and not a file. + const projectRequire = module_1.default.createRequire(projectRoot + '/'); + const localeResolver = (locale) => projectRequire.resolve(path_1.default.join(LOCALE_DATA_BASE_MODULE, locale)); + // Load locale data and translations (if present) + let loader; + const usedFormats = new Set(); + for (const [locale, desc] of Object.entries(i18n.locales)) { + if (!i18n.inlineLocales.has(locale) && locale !== i18n.sourceLocale) { + continue; + } + let localeDataPath = findLocaleDataPath(locale, localeResolver); + if (!localeDataPath) { + const [first] = locale.split('-'); + if (first) { + localeDataPath = findLocaleDataPath(first.toLowerCase(), localeResolver); + if (localeDataPath) { + context.logger.warn(`Locale data for '${locale}' cannot be found. Using locale data for '${first}'.`); + } + } + } + if (!localeDataPath) { + context.logger.warn(`Locale data for '${locale}' cannot be found. No locale data will be included for this locale.`); + } + else { + desc.dataPath = localeDataPath; + } + if (!desc.files.length) { + continue; + } + loader ?? (loader = await (0, load_translations_1.createTranslationLoader)()); + loadTranslations(locale, desc, context.workspaceRoot, loader, { + warn(message) { + context.logger.warn(message); + }, + error(message) { + throw new Error(message); + }, + }, usedFormats, buildOptions.i18nDuplicateTranslation); + if (usedFormats.size > 1 && tsConfig.options.enableI18nLegacyMessageIdFormat !== false) { + // This limitation is only for legacy message id support (defaults to true as of 9.0) + throw new Error('Localization currently only supports using one type of translation file format for the entire application.'); + } + } + // If inlining store the output in a temporary location to facilitate post-processing + if (i18n.shouldInline) { + // TODO: we should likely save these in the .angular directory in the next major version. + // We'd need to do a migration to add the temp directory to gitignore. + const tempPath = fs_1.default.mkdtempSync(path_1.default.join(fs_1.default.realpathSync(os_1.default.tmpdir()), 'angular-cli-i18n-')); + buildOptions.outputPath = tempPath; + process.on('exit', () => { + try { + fs_1.default.rmSync(tempPath, { force: true, recursive: true, maxRetries: 3 }); + } + catch { } + }); + } + return { buildOptions, i18n }; +} +exports.configureI18nBuild = configureI18nBuild; +function findLocaleDataPath(locale, resolver) { + // Remove private use subtags + const scrubbedLocale = locale.replace(/-x(-[a-zA-Z0-9]{1,8})+$/, ''); + try { + return resolver(scrubbedLocale); + } + catch { + // fallback to known existing en-US locale data as of 14.0 + return scrubbedLocale === 'en-US' ? findLocaleDataPath('en', resolver) : null; + } +} +function loadTranslations(locale, desc, workspaceRoot, loader, logger, usedFormats, duplicateTranslation) { + let translations = undefined; + for (const file of desc.files) { + const loadResult = loader(path_1.default.join(workspaceRoot, file.path)); + for (const diagnostics of loadResult.diagnostics.messages) { + if (diagnostics.type === 'error') { + logger.error(`Error parsing translation file '${file.path}': ${diagnostics.message}`); + } + else { + logger.warn(`WARNING [${file.path}]: ${diagnostics.message}`); + } + } + if (loadResult.locale !== undefined && loadResult.locale !== locale) { + logger.warn(`WARNING [${file.path}]: File target locale ('${loadResult.locale}') does not match configured locale ('${locale}')`); + } + usedFormats?.add(loadResult.format); + file.format = loadResult.format; + file.integrity = loadResult.integrity; + if (translations) { + // Merge translations + for (const [id, message] of Object.entries(loadResult.translations)) { + if (translations[id] !== undefined) { + const duplicateTranslationMessage = `[${file.path}]: Duplicate translations for message '${id}' when merging.`; + switch (duplicateTranslation) { + case schema_1.I18NTranslation.Ignore: + break; + case schema_1.I18NTranslation.Error: + logger.error(`ERROR ${duplicateTranslationMessage}`); + break; + case schema_1.I18NTranslation.Warning: + default: + logger.warn(`WARNING ${duplicateTranslationMessage}`); + break; + } + } + translations[id] = message; + } + } + else { + // First or only translation file + translations = loadResult.translations; + } + } + desc.translation = translations; +} +exports.loadTranslations = loadTranslations; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"i18n-options.js","sourceRoot":"","sources":["../../../../../../../../packages/angular_devkit/build_angular/src/utils/i18n-options.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 { BuilderContext } from '@angular-devkit/architect';\nimport { json } from '@angular-devkit/core';\nimport fs from 'fs';\nimport module from 'module';\nimport os from 'os';\nimport path from 'path';\nimport { Schema as BrowserBuilderSchema, I18NTranslation } from '../builders/browser/schema';\nimport { Schema as ServerBuilderSchema } from '../builders/server/schema';\nimport { readTsconfig } from '../utils/read-tsconfig';\nimport { TranslationLoader, createTranslationLoader } from './load-translations';\n\n/**\n * The base module location used to search for locale specific data.\n */\nconst LOCALE_DATA_BASE_MODULE = '@angular/common/locales/global';\n\nexport interface LocaleDescription {\n  files: {\n    path: string;\n    integrity?: string;\n    format?: string;\n  }[];\n  translation?: Record<string, unknown>;\n  dataPath?: string;\n  baseHref?: string;\n}\n\nexport interface I18nOptions {\n  inlineLocales: Set<string>;\n  sourceLocale: string;\n  locales: Record<string, LocaleDescription>;\n  flatOutput?: boolean;\n  readonly shouldInline: boolean;\n  hasDefinedSourceLocale?: boolean;\n}\n\nfunction normalizeTranslationFileOption(\n  option: json.JsonValue,\n  locale: string,\n  expectObjectInError: boolean,\n): string[] {\n  if (typeof option === 'string') {\n    return [option];\n  }\n\n  if (Array.isArray(option) && option.every((element) => typeof element === 'string')) {\n    return option as string[];\n  }\n\n  let errorMessage = `Project i18n locales translation field value for '${locale}' is malformed. `;\n  if (expectObjectInError) {\n    errorMessage += 'Expected a string, array of strings, or object.';\n  } else {\n    errorMessage += 'Expected a string or array of strings.';\n  }\n\n  throw new Error(errorMessage);\n}\n\nexport function createI18nOptions(\n  metadata: json.JsonObject,\n  inline?: boolean | string[],\n): I18nOptions {\n  if (metadata.i18n !== undefined && !json.isJsonObject(metadata.i18n)) {\n    throw new Error('Project i18n field is malformed. Expected an object.');\n  }\n  metadata = metadata.i18n || {};\n\n  const i18n: I18nOptions = {\n    inlineLocales: new Set<string>(),\n    // en-US is the default locale added to Angular applications (https://angular.io/guide/i18n#i18n-pipes)\n    sourceLocale: 'en-US',\n    locales: {},\n    get shouldInline() {\n      return this.inlineLocales.size > 0;\n    },\n  };\n\n  let rawSourceLocale;\n  let rawSourceLocaleBaseHref;\n  if (json.isJsonObject(metadata.sourceLocale)) {\n    rawSourceLocale = metadata.sourceLocale.code;\n    if (\n      metadata.sourceLocale.baseHref !== undefined &&\n      typeof metadata.sourceLocale.baseHref !== 'string'\n    ) {\n      throw new Error('Project i18n sourceLocale baseHref field is malformed. Expected a string.');\n    }\n    rawSourceLocaleBaseHref = metadata.sourceLocale.baseHref;\n  } else {\n    rawSourceLocale = metadata.sourceLocale;\n  }\n\n  if (rawSourceLocale !== undefined) {\n    if (typeof rawSourceLocale !== 'string') {\n      throw new Error('Project i18n sourceLocale field is malformed. Expected a string.');\n    }\n\n    i18n.sourceLocale = rawSourceLocale;\n    i18n.hasDefinedSourceLocale = true;\n  }\n\n  i18n.locales[i18n.sourceLocale] = {\n    files: [],\n    baseHref: rawSourceLocaleBaseHref,\n  };\n\n  if (metadata.locales !== undefined && !json.isJsonObject(metadata.locales)) {\n    throw new Error('Project i18n locales field is malformed. Expected an object.');\n  } else if (metadata.locales) {\n    for (const [locale, options] of Object.entries(metadata.locales)) {\n      let translationFiles;\n      let baseHref;\n      if (json.isJsonObject(options)) {\n        translationFiles = normalizeTranslationFileOption(options.translation, locale, false);\n\n        if (typeof options.baseHref === 'string') {\n          baseHref = options.baseHref;\n        }\n      } else {\n        translationFiles = normalizeTranslationFileOption(options, locale, true);\n      }\n\n      if (locale === i18n.sourceLocale) {\n        throw new Error(\n          `An i18n locale ('${locale}') cannot both be a source locale and provide a translation.`,\n        );\n      }\n\n      i18n.locales[locale] = {\n        files: translationFiles.map((file) => ({ path: file })),\n        baseHref,\n      };\n    }\n  }\n\n  if (inline === true) {\n    i18n.inlineLocales.add(i18n.sourceLocale);\n    Object.keys(i18n.locales).forEach((locale) => i18n.inlineLocales.add(locale));\n  } else if (inline) {\n    for (const locale of inline) {\n      if (!i18n.locales[locale] && i18n.sourceLocale !== locale) {\n        throw new Error(`Requested locale '${locale}' is not defined for the project.`);\n      }\n\n      i18n.inlineLocales.add(locale);\n    }\n  }\n\n  return i18n;\n}\n\nexport async function configureI18nBuild<T extends BrowserBuilderSchema | ServerBuilderSchema>(\n  context: BuilderContext,\n  options: T,\n): Promise<{\n  buildOptions: T;\n  i18n: I18nOptions;\n}> {\n  if (!context.target) {\n    throw new Error('The builder requires a target.');\n  }\n\n  const buildOptions = { ...options };\n  const tsConfig = await readTsconfig(buildOptions.tsConfig, context.workspaceRoot);\n  const metadata = await context.getProjectMetadata(context.target);\n  const i18n = createI18nOptions(metadata, buildOptions.localize);\n\n  // No additional processing needed if no inlining requested and no source locale defined.\n  if (!i18n.shouldInline && !i18n.hasDefinedSourceLocale) {\n    return { buildOptions, i18n };\n  }\n\n  const projectRoot = path.join(context.workspaceRoot, (metadata.root as string) || '');\n  // The trailing slash is required to signal that the path is a directory and not a file.\n  const projectRequire = module.createRequire(projectRoot + '/');\n  const localeResolver = (locale: string) =>\n    projectRequire.resolve(path.join(LOCALE_DATA_BASE_MODULE, locale));\n\n  // Load locale data and translations (if present)\n  let loader;\n  const usedFormats = new Set<string>();\n  for (const [locale, desc] of Object.entries(i18n.locales)) {\n    if (!i18n.inlineLocales.has(locale) && locale !== i18n.sourceLocale) {\n      continue;\n    }\n\n    let localeDataPath = findLocaleDataPath(locale, localeResolver);\n    if (!localeDataPath) {\n      const [first] = locale.split('-');\n      if (first) {\n        localeDataPath = findLocaleDataPath(first.toLowerCase(), localeResolver);\n        if (localeDataPath) {\n          context.logger.warn(\n            `Locale data for '${locale}' cannot be found. Using locale data for '${first}'.`,\n          );\n        }\n      }\n    }\n    if (!localeDataPath) {\n      context.logger.warn(\n        `Locale data for '${locale}' cannot be found. No locale data will be included for this locale.`,\n      );\n    } else {\n      desc.dataPath = localeDataPath;\n    }\n\n    if (!desc.files.length) {\n      continue;\n    }\n\n    loader ??= await createTranslationLoader();\n\n    loadTranslations(\n      locale,\n      desc,\n      context.workspaceRoot,\n      loader,\n      {\n        warn(message) {\n          context.logger.warn(message);\n        },\n        error(message) {\n          throw new Error(message);\n        },\n      },\n      usedFormats,\n      buildOptions.i18nDuplicateTranslation,\n    );\n\n    if (usedFormats.size > 1 && tsConfig.options.enableI18nLegacyMessageIdFormat !== false) {\n      // This limitation is only for legacy message id support (defaults to true as of 9.0)\n      throw new Error(\n        'Localization currently only supports using one type of translation file format for the entire application.',\n      );\n    }\n  }\n\n  // If inlining store the output in a temporary location to facilitate post-processing\n  if (i18n.shouldInline) {\n    // TODO: we should likely save these in the .angular directory in the next major version.\n    // We'd need to do a migration to add the temp directory to gitignore.\n    const tempPath = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'angular-cli-i18n-'));\n    buildOptions.outputPath = tempPath;\n\n    process.on('exit', () => {\n      try {\n        fs.rmSync(tempPath, { force: true, recursive: true, maxRetries: 3 });\n      } catch {}\n    });\n  }\n\n  return { buildOptions, i18n };\n}\n\nfunction findLocaleDataPath(locale: string, resolver: (locale: string) => string): string | null {\n  // Remove private use subtags\n  const scrubbedLocale = locale.replace(/-x(-[a-zA-Z0-9]{1,8})+$/, '');\n\n  try {\n    return resolver(scrubbedLocale);\n  } catch {\n    // fallback to known existing en-US locale data as of 14.0\n    return scrubbedLocale === 'en-US' ? findLocaleDataPath('en', resolver) : null;\n  }\n}\n\nexport function loadTranslations(\n  locale: string,\n  desc: LocaleDescription,\n  workspaceRoot: string,\n  loader: TranslationLoader,\n  logger: { warn: (message: string) => void; error: (message: string) => void },\n  usedFormats?: Set<string>,\n  duplicateTranslation?: I18NTranslation,\n) {\n  let translations: Record<string, unknown> | undefined = undefined;\n  for (const file of desc.files) {\n    const loadResult = loader(path.join(workspaceRoot, file.path));\n\n    for (const diagnostics of loadResult.diagnostics.messages) {\n      if (diagnostics.type === 'error') {\n        logger.error(`Error parsing translation file '${file.path}': ${diagnostics.message}`);\n      } else {\n        logger.warn(`WARNING [${file.path}]: ${diagnostics.message}`);\n      }\n    }\n\n    if (loadResult.locale !== undefined && loadResult.locale !== locale) {\n      logger.warn(\n        `WARNING [${file.path}]: File target locale ('${loadResult.locale}') does not match configured locale ('${locale}')`,\n      );\n    }\n\n    usedFormats?.add(loadResult.format);\n    file.format = loadResult.format;\n    file.integrity = loadResult.integrity;\n\n    if (translations) {\n      // Merge translations\n      for (const [id, message] of Object.entries(loadResult.translations)) {\n        if (translations[id] !== undefined) {\n          const duplicateTranslationMessage = `[${file.path}]: Duplicate translations for message '${id}' when merging.`;\n          switch (duplicateTranslation) {\n            case I18NTranslation.Ignore:\n              break;\n            case I18NTranslation.Error:\n              logger.error(`ERROR ${duplicateTranslationMessage}`);\n              break;\n            case I18NTranslation.Warning:\n            default:\n              logger.warn(`WARNING ${duplicateTranslationMessage}`);\n              break;\n          }\n        }\n        translations[id] = message;\n      }\n    } else {\n      // First or only translation file\n      translations = loadResult.translations;\n    }\n  }\n  desc.translation = translations;\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/utils/index-file/augment-index-html.d.ts b/artifacts/build-angular/src/utils/index-file/augment-index-html.d.ts new file mode 100644 index 00000000..dc1e625f --- /dev/null +++ b/artifacts/build-angular/src/utils/index-file/augment-index-html.d.ts @@ -0,0 +1,34 @@ +/** + * @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 + */ +export type LoadOutputFileFunctionType = (file: string) => Promise; +export type CrossOriginValue = 'none' | 'anonymous' | 'use-credentials'; +export type Entrypoint = [name: string, isModule: boolean]; +export interface AugmentIndexHtmlOptions { + html: string; + baseHref?: string; + deployUrl?: string; + sri: boolean; + /** crossorigin attribute setting of elements that provide CORS support */ + crossOrigin?: CrossOriginValue; + files: FileInfo[]; + loadOutputFile: LoadOutputFileFunctionType; + /** Used to sort the inseration of files in the HTML file */ + entrypoints: Entrypoint[]; + /** Used to set the document default locale */ + lang?: string; +} +export interface FileInfo { + file: string; + name: string; + extension: string; +} +export declare function augmentIndexHtml(params: AugmentIndexHtmlOptions): Promise<{ + content: string; + warnings: string[]; + errors: string[]; +}>; diff --git a/artifacts/build-angular/src/utils/index-file/augment-index-html.js b/artifacts/build-angular/src/utils/index-file/augment-index-html.js new file mode 100644 index 00000000..6c93e00e --- /dev/null +++ b/artifacts/build-angular/src/utils/index-file/augment-index-html.js @@ -0,0 +1,188 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.augmentIndexHtml = void 0; +const crypto_1 = require("crypto"); +const load_esm_1 = require("../load-esm"); +const html_rewriting_stream_1 = require("./html-rewriting-stream"); +/* + * Helper function used by the IndexHtmlWebpackPlugin. + * Can also be directly used by builder, e. g. in order to generate an index.html + * after processing several configurations in order to build different sets of + * bundles for differential serving. + */ +async function augmentIndexHtml(params) { + const { loadOutputFile, files, entrypoints, sri, deployUrl = '', lang, baseHref, html } = params; + const warnings = []; + const errors = []; + let { crossOrigin = 'none' } = params; + if (sri && crossOrigin === 'none') { + crossOrigin = 'anonymous'; + } + const stylesheets = new Set(); + const scripts = new Map(); + // Sort files in the order we want to insert them by entrypoint + for (const [entrypoint, isModule] of entrypoints) { + for (const { extension, file, name } of files) { + if (name !== entrypoint || scripts.has(file) || stylesheets.has(file)) { + continue; + } + switch (extension) { + case '.js': + // Also, non entrypoints need to be loaded as no module as they can contain problematic code. + scripts.set(file, isModule); + break; + case '.mjs': + if (!isModule) { + // It would be very confusing to link an `*.mjs` file in a non-module script context, + // so we disallow it entirely. + throw new Error('`.mjs` files *must* set `isModule` to `true`.'); + } + scripts.set(file, true /* isModule */); + break; + case '.css': + stylesheets.add(file); + break; + } + } + } + let scriptTags = []; + for (const [src, isModule] of scripts) { + const attrs = [`src="${deployUrl}${src}"`]; + // This is also need for non entry-points as they may contain problematic code. + if (isModule) { + attrs.push('type="module"'); + } + else { + attrs.push('defer'); + } + if (crossOrigin !== 'none') { + attrs.push(`crossorigin="${crossOrigin}"`); + } + if (sri) { + const content = await loadOutputFile(src); + attrs.push(generateSriAttributes(content)); + } + scriptTags.push(``); + } + let linkTags = []; + for (const src of stylesheets) { + const attrs = [`rel="stylesheet"`, `href="${deployUrl}${src}"`]; + if (crossOrigin !== 'none') { + attrs.push(`crossorigin="${crossOrigin}"`); + } + if (sri) { + const content = await loadOutputFile(src); + attrs.push(generateSriAttributes(content)); + } + linkTags.push(``); + } + const dir = lang ? await getLanguageDirection(lang, warnings) : undefined; + const { rewriter, transformedContent } = await (0, html_rewriting_stream_1.htmlRewritingStream)(html); + const baseTagExists = html.includes(' { + switch (tag.tagName) { + case 'html': + // Adjust document locale if specified + if (isString(lang)) { + updateAttribute(tag, 'lang', lang); + } + if (dir) { + updateAttribute(tag, 'dir', dir); + } + break; + case 'head': + // Base href should be added before any link, meta tags + if (!baseTagExists && isString(baseHref)) { + rewriter.emitStartTag(tag); + rewriter.emitRaw(``); + return; + } + break; + case 'base': + // Adjust base href if specified + if (isString(baseHref)) { + updateAttribute(tag, 'href', baseHref); + } + break; + } + rewriter.emitStartTag(tag); + }) + .on('endTag', (tag) => { + switch (tag.tagName) { + case 'head': + for (const linkTag of linkTags) { + rewriter.emitRaw(linkTag); + } + linkTags = []; + break; + case 'body': + // Add script tags + for (const scriptTag of scriptTags) { + rewriter.emitRaw(scriptTag); + } + scriptTags = []; + break; + } + rewriter.emitEndTag(tag); + }); + const content = await transformedContent(); + return { + content: linkTags.length || scriptTags.length + ? // In case no body/head tags are not present (dotnet partial templates) + linkTags.join('') + scriptTags.join('') + content + : content, + warnings, + errors, + }; +} +exports.augmentIndexHtml = augmentIndexHtml; +function generateSriAttributes(content) { + const algo = 'sha384'; + const hash = (0, crypto_1.createHash)(algo).update(content, 'utf8').digest('base64'); + return `integrity="${algo}-${hash}"`; +} +function updateAttribute(tag, name, value) { + const index = tag.attrs.findIndex((a) => a.name === name); + const newValue = { name, value }; + if (index === -1) { + tag.attrs.push(newValue); + } + else { + tag.attrs[index] = newValue; + } +} +function isString(value) { + return typeof value === 'string'; +} +async function getLanguageDirection(locale, warnings) { + const dir = await getLanguageDirectionFromLocales(locale); + if (!dir) { + warnings.push(`Locale data for '${locale}' cannot be found. 'dir' attribute will not be set for this locale.`); + } + return dir; +} +async function getLanguageDirectionFromLocales(locale) { + try { + const localeData = (await (0, load_esm_1.loadEsmModule)(`@angular/common/locales/${locale}`)).default; + const dir = localeData[localeData.length - 2]; + return isString(dir) ? dir : undefined; + } + catch { + // In some cases certain locales might map to files which are named only with language id. + // Example: `en-US` -> `en`. + const [languageId] = locale.split('-', 1); + if (languageId !== locale) { + return getLanguageDirectionFromLocales(languageId); + } + } + return undefined; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"augment-index-html.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/utils/index-file/augment-index-html.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 { createHash } from 'crypto';\nimport { loadEsmModule } from '../load-esm';\nimport { htmlRewritingStream } from './html-rewriting-stream';\n\nexport type LoadOutputFileFunctionType = (file: string) => Promise<string>;\n\nexport type CrossOriginValue = 'none' | 'anonymous' | 'use-credentials';\n\nexport type Entrypoint = [name: string, isModule: boolean];\n\nexport interface AugmentIndexHtmlOptions {\n  /* Input contents */\n  html: string;\n  baseHref?: string;\n  deployUrl?: string;\n  sri: boolean;\n  /** crossorigin attribute setting of elements that provide CORS support */\n  crossOrigin?: CrossOriginValue;\n  /*\n   * Files emitted by the build.\n   */\n  files: FileInfo[];\n  /*\n   * Function that loads a file used.\n   * This allows us to use different routines within the IndexHtmlWebpackPlugin and\n   * when used without this plugin.\n   */\n  loadOutputFile: LoadOutputFileFunctionType;\n  /** Used to sort the inseration of files in the HTML file */\n  entrypoints: Entrypoint[];\n  /** Used to set the document default locale */\n  lang?: string;\n}\n\nexport interface FileInfo {\n  file: string;\n  name: string;\n  extension: string;\n}\n/*\n * Helper function used by the IndexHtmlWebpackPlugin.\n * Can also be directly used by builder, e. g. in order to generate an index.html\n * after processing several configurations in order to build different sets of\n * bundles for differential serving.\n */\nexport async function augmentIndexHtml(\n  params: AugmentIndexHtmlOptions,\n): Promise<{ content: string; warnings: string[]; errors: string[] }> {\n  const { loadOutputFile, files, entrypoints, sri, deployUrl = '', lang, baseHref, html } = params;\n\n  const warnings: string[] = [];\n  const errors: string[] = [];\n\n  let { crossOrigin = 'none' } = params;\n  if (sri && crossOrigin === 'none') {\n    crossOrigin = 'anonymous';\n  }\n\n  const stylesheets = new Set<string>();\n  const scripts = new Map</** file name */ string, /** isModule */ boolean>();\n\n  // Sort files in the order we want to insert them by entrypoint\n  for (const [entrypoint, isModule] of entrypoints) {\n    for (const { extension, file, name } of files) {\n      if (name !== entrypoint || scripts.has(file) || stylesheets.has(file)) {\n        continue;\n      }\n\n      switch (extension) {\n        case '.js':\n          // Also, non entrypoints need to be loaded as no module as they can contain problematic code.\n          scripts.set(file, isModule);\n          break;\n        case '.mjs':\n          if (!isModule) {\n            // It would be very confusing to link an `*.mjs` file in a non-module script context,\n            // so we disallow it entirely.\n            throw new Error('`.mjs` files *must* set `isModule` to `true`.');\n          }\n          scripts.set(file, true /* isModule */);\n          break;\n        case '.css':\n          stylesheets.add(file);\n          break;\n      }\n    }\n  }\n\n  let scriptTags: string[] = [];\n  for (const [src, isModule] of scripts) {\n    const attrs = [`src=\"${deployUrl}${src}\"`];\n\n    // This is also need for non entry-points as they may contain problematic code.\n    if (isModule) {\n      attrs.push('type=\"module\"');\n    } else {\n      attrs.push('defer');\n    }\n\n    if (crossOrigin !== 'none') {\n      attrs.push(`crossorigin=\"${crossOrigin}\"`);\n    }\n\n    if (sri) {\n      const content = await loadOutputFile(src);\n      attrs.push(generateSriAttributes(content));\n    }\n\n    scriptTags.push(`<script ${attrs.join(' ')}></script>`);\n  }\n\n  let linkTags: string[] = [];\n  for (const src of stylesheets) {\n    const attrs = [`rel=\"stylesheet\"`, `href=\"${deployUrl}${src}\"`];\n\n    if (crossOrigin !== 'none') {\n      attrs.push(`crossorigin=\"${crossOrigin}\"`);\n    }\n\n    if (sri) {\n      const content = await loadOutputFile(src);\n      attrs.push(generateSriAttributes(content));\n    }\n\n    linkTags.push(`<link ${attrs.join(' ')}>`);\n  }\n\n  const dir = lang ? await getLanguageDirection(lang, warnings) : undefined;\n  const { rewriter, transformedContent } = await htmlRewritingStream(html);\n  const baseTagExists = html.includes('<base');\n\n  rewriter\n    .on('startTag', (tag) => {\n      switch (tag.tagName) {\n        case 'html':\n          // Adjust document locale if specified\n          if (isString(lang)) {\n            updateAttribute(tag, 'lang', lang);\n          }\n\n          if (dir) {\n            updateAttribute(tag, 'dir', dir);\n          }\n          break;\n        case 'head':\n          // Base href should be added before any link, meta tags\n          if (!baseTagExists && isString(baseHref)) {\n            rewriter.emitStartTag(tag);\n            rewriter.emitRaw(`<base href=\"${baseHref}\">`);\n\n            return;\n          }\n          break;\n        case 'base':\n          // Adjust base href if specified\n          if (isString(baseHref)) {\n            updateAttribute(tag, 'href', baseHref);\n          }\n          break;\n      }\n\n      rewriter.emitStartTag(tag);\n    })\n    .on('endTag', (tag) => {\n      switch (tag.tagName) {\n        case 'head':\n          for (const linkTag of linkTags) {\n            rewriter.emitRaw(linkTag);\n          }\n\n          linkTags = [];\n          break;\n        case 'body':\n          // Add script tags\n          for (const scriptTag of scriptTags) {\n            rewriter.emitRaw(scriptTag);\n          }\n\n          scriptTags = [];\n          break;\n      }\n\n      rewriter.emitEndTag(tag);\n    });\n\n  const content = await transformedContent();\n\n  return {\n    content:\n      linkTags.length || scriptTags.length\n        ? // In case no body/head tags are not present (dotnet partial templates)\n          linkTags.join('') + scriptTags.join('') + content\n        : content,\n    warnings,\n    errors,\n  };\n}\n\nfunction generateSriAttributes(content: string): string {\n  const algo = 'sha384';\n  const hash = createHash(algo).update(content, 'utf8').digest('base64');\n\n  return `integrity=\"${algo}-${hash}\"`;\n}\n\nfunction updateAttribute(\n  tag: { attrs: { name: string; value: string }[] },\n  name: string,\n  value: string,\n): void {\n  const index = tag.attrs.findIndex((a) => a.name === name);\n  const newValue = { name, value };\n\n  if (index === -1) {\n    tag.attrs.push(newValue);\n  } else {\n    tag.attrs[index] = newValue;\n  }\n}\n\nfunction isString(value: unknown): value is string {\n  return typeof value === 'string';\n}\n\nasync function getLanguageDirection(\n  locale: string,\n  warnings: string[],\n): Promise<string | undefined> {\n  const dir = await getLanguageDirectionFromLocales(locale);\n\n  if (!dir) {\n    warnings.push(\n      `Locale data for '${locale}' cannot be found. 'dir' attribute will not be set for this locale.`,\n    );\n  }\n\n  return dir;\n}\n\nasync function getLanguageDirectionFromLocales(locale: string): Promise<string | undefined> {\n  try {\n    const localeData = (\n      await loadEsmModule<typeof import('@angular/common/locales/en')>(\n        `@angular/common/locales/${locale}`,\n      )\n    ).default;\n\n    const dir = localeData[localeData.length - 2];\n\n    return isString(dir) ? dir : undefined;\n  } catch {\n    // In some cases certain locales might map to files which are named only with language id.\n    // Example: `en-US` -> `en`.\n    const [languageId] = locale.split('-', 1);\n    if (languageId !== locale) {\n      return getLanguageDirectionFromLocales(languageId);\n    }\n  }\n\n  return undefined;\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/utils/index-file/html-rewriting-stream.d.ts b/artifacts/build-angular/src/utils/index-file/html-rewriting-stream.d.ts new file mode 100644 index 00000000..0616852b --- /dev/null +++ b/artifacts/build-angular/src/utils/index-file/html-rewriting-stream.d.ts @@ -0,0 +1,11 @@ +/** + * @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 + */ +export declare function htmlRewritingStream(content: string): Promise<{ + rewriter: import('parse5-html-rewriting-stream').RewritingStream; + transformedContent: () => Promise; +}>; diff --git a/artifacts/build-angular/src/utils/index-file/html-rewriting-stream.js b/artifacts/build-angular/src/utils/index-file/html-rewriting-stream.js new file mode 100644 index 00000000..a8019ace --- /dev/null +++ b/artifacts/build-angular/src/utils/index-file/html-rewriting-stream.js @@ -0,0 +1,46 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.htmlRewritingStream = void 0; +const stream_1 = require("stream"); +const load_esm_1 = require("../load-esm"); +async function htmlRewritingStream(content) { + const { RewritingStream } = await (0, load_esm_1.loadEsmModule)('parse5-html-rewriting-stream'); + const chunks = []; + const rewriter = new RewritingStream(); + return { + rewriter, + transformedContent: () => { + return new Promise((resolve) => { + new stream_1.Readable({ + encoding: 'utf8', + read() { + this.push(Buffer.from(content)); + this.push(null); + }, + }) + .pipe(rewriter) + .pipe(new stream_1.Writable({ + write(chunk, encoding, callback) { + chunks.push(typeof chunk === 'string' + ? Buffer.from(chunk, encoding) + : chunk); + callback(); + }, + final(callback) { + callback(); + resolve(Buffer.concat(chunks).toString()); + }, + })); + }); + }, + }; +} +exports.htmlRewritingStream = htmlRewritingStream; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/artifacts/build-angular/src/utils/index-file/index-html-generator.d.ts b/artifacts/build-angular/src/utils/index-file/index-html-generator.d.ts new file mode 100644 index 00000000..1d99afc9 --- /dev/null +++ b/artifacts/build-angular/src/utils/index-file/index-html-generator.d.ts @@ -0,0 +1,40 @@ +/** + * @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 { NormalizedCachedOptions } from '../normalize-cache'; +import { NormalizedOptimizationOptions } from '../normalize-optimization'; +import { CrossOriginValue, Entrypoint, FileInfo } from './augment-index-html'; +export interface IndexHtmlGeneratorProcessOptions { + lang: string | undefined; + baseHref: string | undefined; + outputPath: string; + files: FileInfo[]; +} +export interface IndexHtmlGeneratorOptions { + indexPath: string; + deployUrl?: string; + sri?: boolean; + entrypoints: Entrypoint[]; + postTransform?: IndexHtmlTransform; + crossOrigin?: CrossOriginValue; + optimization?: NormalizedOptimizationOptions; + cache?: NormalizedCachedOptions; +} +export type IndexHtmlTransform = (content: string) => Promise; +export interface IndexHtmlTransformResult { + content: string; + warnings: string[]; + errors: string[]; +} +export declare class IndexHtmlGenerator { + readonly options: IndexHtmlGeneratorOptions; + private readonly plugins; + constructor(options: IndexHtmlGeneratorOptions); + process(options: IndexHtmlGeneratorProcessOptions): Promise; + readAsset(path: string): Promise; + protected readIndex(path: string): Promise; +} diff --git a/artifacts/build-angular/src/utils/index-file/index-html-generator.js b/artifacts/build-angular/src/utils/index-file/index-html-generator.js new file mode 100644 index 00000000..cf95644f --- /dev/null +++ b/artifacts/build-angular/src/utils/index-file/index-html-generator.js @@ -0,0 +1,130 @@ +"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.IndexHtmlGenerator = void 0; +const fs = __importStar(require("fs")); +const path_1 = require("path"); +const strip_bom_1 = require("../strip-bom"); +const augment_index_html_1 = require("./augment-index-html"); +const inline_critical_css_1 = require("./inline-critical-css"); +const inline_fonts_1 = require("./inline-fonts"); +const style_nonce_1 = require("./style-nonce"); +class IndexHtmlGenerator { + constructor(options) { + this.options = options; + const extraPlugins = []; + if (this.options.optimization?.fonts.inline) { + extraPlugins.push(inlineFontsPlugin(this)); + } + if (this.options.optimization?.styles.inlineCritical) { + extraPlugins.push(inlineCriticalCssPlugin(this)); + } + this.plugins = [ + augmentIndexHtmlPlugin(this), + ...extraPlugins, + // Runs after the `extraPlugins` to capture any nonce or + // `style` tags that might've been added by them. + addStyleNoncePlugin(), + postTransformPlugin(this), + ]; + } + async process(options) { + let content = (0, strip_bom_1.stripBom)(await this.readIndex(this.options.indexPath)); + const warnings = []; + const errors = []; + for (const plugin of this.plugins) { + const result = await plugin(content, options); + if (typeof result === 'string') { + content = result; + } + else { + content = result.content; + if (result.warnings.length) { + warnings.push(...result.warnings); + } + if (result.errors.length) { + errors.push(...result.errors); + } + } + } + return { + content, + warnings, + errors, + }; + } + async readAsset(path) { + return fs.promises.readFile(path, 'utf-8'); + } + async readIndex(path) { + return fs.promises.readFile(path, 'utf-8'); + } +} +exports.IndexHtmlGenerator = IndexHtmlGenerator; +function augmentIndexHtmlPlugin(generator) { + const { deployUrl, crossOrigin, sri = false, entrypoints } = generator.options; + return async (html, options) => { + const { lang, baseHref, outputPath = '', files } = options; + return (0, augment_index_html_1.augmentIndexHtml)({ + html, + baseHref, + deployUrl, + crossOrigin, + sri, + lang, + entrypoints, + loadOutputFile: (filePath) => generator.readAsset((0, path_1.join)(outputPath, filePath)), + files, + }); + }; +} +function inlineFontsPlugin({ options }) { + const inlineFontsProcessor = new inline_fonts_1.InlineFontsProcessor({ + minify: options.optimization?.styles.minify, + }); + return async (html) => inlineFontsProcessor.process(html); +} +function inlineCriticalCssPlugin(generator) { + const inlineCriticalCssProcessor = new inline_critical_css_1.InlineCriticalCssProcessor({ + minify: generator.options.optimization?.styles.minify, + deployUrl: generator.options.deployUrl, + readAsset: (filePath) => generator.readAsset(filePath), + }); + return async (html, options) => inlineCriticalCssProcessor.process(html, { outputPath: options.outputPath }); +} +function addStyleNoncePlugin() { + return (html) => (0, style_nonce_1.addStyleNonce)(html); +} +function postTransformPlugin({ options }) { + return async (html) => (options.postTransform ? options.postTransform(html) : html); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index-html-generator.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/utils/index-file/index-html-generator.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 * as fs from 'fs';\nimport { join } from 'path';\nimport { NormalizedCachedOptions } from '../normalize-cache';\nimport { NormalizedOptimizationOptions } from '../normalize-optimization';\nimport { stripBom } from '../strip-bom';\nimport { CrossOriginValue, Entrypoint, FileInfo, augmentIndexHtml } from './augment-index-html';\nimport { InlineCriticalCssProcessor } from './inline-critical-css';\nimport { InlineFontsProcessor } from './inline-fonts';\nimport { addStyleNonce } from './style-nonce';\n\ntype IndexHtmlGeneratorPlugin = (\n  html: string,\n  options: IndexHtmlGeneratorProcessOptions,\n) => Promise<string | IndexHtmlTransformResult>;\n\nexport interface IndexHtmlGeneratorProcessOptions {\n  lang: string | undefined;\n  baseHref: string | undefined;\n  outputPath: string;\n  files: FileInfo[];\n}\n\nexport interface IndexHtmlGeneratorOptions {\n  indexPath: string;\n  deployUrl?: string;\n  sri?: boolean;\n  entrypoints: Entrypoint[];\n  postTransform?: IndexHtmlTransform;\n  crossOrigin?: CrossOriginValue;\n  optimization?: NormalizedOptimizationOptions;\n  cache?: NormalizedCachedOptions;\n}\n\nexport type IndexHtmlTransform = (content: string) => Promise<string>;\n\nexport interface IndexHtmlTransformResult {\n  content: string;\n  warnings: string[];\n  errors: string[];\n}\n\nexport class IndexHtmlGenerator {\n  private readonly plugins: IndexHtmlGeneratorPlugin[];\n\n  constructor(readonly options: IndexHtmlGeneratorOptions) {\n    const extraPlugins: IndexHtmlGeneratorPlugin[] = [];\n    if (this.options.optimization?.fonts.inline) {\n      extraPlugins.push(inlineFontsPlugin(this));\n    }\n\n    if (this.options.optimization?.styles.inlineCritical) {\n      extraPlugins.push(inlineCriticalCssPlugin(this));\n    }\n\n    this.plugins = [\n      augmentIndexHtmlPlugin(this),\n      ...extraPlugins,\n      // Runs after the `extraPlugins` to capture any nonce or\n      // `style` tags that might've been added by them.\n      addStyleNoncePlugin(),\n      postTransformPlugin(this),\n    ];\n  }\n\n  async process(options: IndexHtmlGeneratorProcessOptions): Promise<IndexHtmlTransformResult> {\n    let content = stripBom(await this.readIndex(this.options.indexPath));\n    const warnings: string[] = [];\n    const errors: string[] = [];\n\n    for (const plugin of this.plugins) {\n      const result = await plugin(content, options);\n      if (typeof result === 'string') {\n        content = result;\n      } else {\n        content = result.content;\n\n        if (result.warnings.length) {\n          warnings.push(...result.warnings);\n        }\n\n        if (result.errors.length) {\n          errors.push(...result.errors);\n        }\n      }\n    }\n\n    return {\n      content,\n      warnings,\n      errors,\n    };\n  }\n\n  async readAsset(path: string): Promise<string> {\n    return fs.promises.readFile(path, 'utf-8');\n  }\n\n  protected async readIndex(path: string): Promise<string> {\n    return fs.promises.readFile(path, 'utf-8');\n  }\n}\n\nfunction augmentIndexHtmlPlugin(generator: IndexHtmlGenerator): IndexHtmlGeneratorPlugin {\n  const { deployUrl, crossOrigin, sri = false, entrypoints } = generator.options;\n\n  return async (html, options) => {\n    const { lang, baseHref, outputPath = '', files } = options;\n\n    return augmentIndexHtml({\n      html,\n      baseHref,\n      deployUrl,\n      crossOrigin,\n      sri,\n      lang,\n      entrypoints,\n      loadOutputFile: (filePath) => generator.readAsset(join(outputPath, filePath)),\n      files,\n    });\n  };\n}\n\nfunction inlineFontsPlugin({ options }: IndexHtmlGenerator): IndexHtmlGeneratorPlugin {\n  const inlineFontsProcessor = new InlineFontsProcessor({\n    minify: options.optimization?.styles.minify,\n  });\n\n  return async (html) => inlineFontsProcessor.process(html);\n}\n\nfunction inlineCriticalCssPlugin(generator: IndexHtmlGenerator): IndexHtmlGeneratorPlugin {\n  const inlineCriticalCssProcessor = new InlineCriticalCssProcessor({\n    minify: generator.options.optimization?.styles.minify,\n    deployUrl: generator.options.deployUrl,\n    readAsset: (filePath) => generator.readAsset(filePath),\n  });\n\n  return async (html, options) =>\n    inlineCriticalCssProcessor.process(html, { outputPath: options.outputPath });\n}\n\nfunction addStyleNoncePlugin(): IndexHtmlGeneratorPlugin {\n  return (html) => addStyleNonce(html);\n}\n\nfunction postTransformPlugin({ options }: IndexHtmlGenerator): IndexHtmlGeneratorPlugin {\n  return async (html) => (options.postTransform ? options.postTransform(html) : html);\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/utils/index-file/inline-critical-css.d.ts b/artifacts/build-angular/src/utils/index-file/inline-critical-css.d.ts new file mode 100644 index 00000000..52efae61 --- /dev/null +++ b/artifacts/build-angular/src/utils/index-file/inline-critical-css.d.ts @@ -0,0 +1,24 @@ +/** + * @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 + */ +export interface InlineCriticalCssProcessOptions { + outputPath: string; +} +export interface InlineCriticalCssProcessorOptions { + minify?: boolean; + deployUrl?: string; + readAsset?: (path: string) => Promise; +} +export declare class InlineCriticalCssProcessor { + protected readonly options: InlineCriticalCssProcessorOptions; + constructor(options: InlineCriticalCssProcessorOptions); + process(html: string, options: InlineCriticalCssProcessOptions): Promise<{ + content: string; + warnings: string[]; + errors: string[]; + }>; +} diff --git a/artifacts/build-angular/src/utils/index-file/inline-critical-css.js b/artifacts/build-angular/src/utils/index-file/inline-critical-css.js new file mode 100644 index 00000000..51a0e39e --- /dev/null +++ b/artifacts/build-angular/src/utils/index-file/inline-critical-css.js @@ -0,0 +1,171 @@ +"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.InlineCriticalCssProcessor = void 0; +const fs = __importStar(require("fs")); +const Critters = require('critters'); +/** + * Pattern used to extract the media query set by Critters in an `onload` handler. + */ +const MEDIA_SET_HANDLER_PATTERN = /^this\.media=["'](.*)["'];?$/; +/** + * Name of the attribute used to save the Critters media query so it can be re-assigned on load. + */ +const CSP_MEDIA_ATTR = 'ngCspMedia'; +/** + * Script text used to change the media value of the link tags. + */ +const LINK_LOAD_SCRIPT_CONTENT = [ + `(() => {`, + // Save the `children` in a variable since they're a live DOM node collection. + // We iterate over the direct descendants, instead of going through a `querySelectorAll`, + // because we know that the tags will be directly inside the `head`. + ` const children = document.head.children;`, + // Declare `onLoad` outside the loop to avoid leaking memory. + // Can't be an arrow function, because we need `this` to refer to the DOM node. + ` function onLoad() {this.media = this.getAttribute('${CSP_MEDIA_ATTR}');}`, + // Has to use a plain for loop, because some browsers don't support + // `forEach` on `children` which is a `HTMLCollection`. + ` for (let i = 0; i < children.length; i++) {`, + ` const child = children[i];`, + ` child.hasAttribute('${CSP_MEDIA_ATTR}') && child.addEventListener('load', onLoad);`, + ` }`, + `})();`, +].join('\n'); +class CrittersExtended extends Critters { + constructor(optionsExtended) { + super({ + logger: { + warn: (s) => this.warnings.push(s), + error: (s) => this.errors.push(s), + info: () => { }, + }, + logLevel: 'warn', + path: optionsExtended.outputPath, + publicPath: optionsExtended.deployUrl, + compress: !!optionsExtended.minify, + pruneSource: false, + reduceInlineStyles: false, + mergeStylesheets: false, + // Note: if `preload` changes to anything other than `media`, the logic in + // `embedLinkedStylesheetOverride` will have to be updated. + preload: 'media', + noscriptFallback: true, + inlineFonts: true, + }); + this.optionsExtended = optionsExtended; + this.warnings = []; + this.errors = []; + this.addedCspScriptsDocuments = new WeakSet(); + this.documentNonces = new WeakMap(); + /** + * Override of the Critters `embedLinkedStylesheet` method + * that makes it work with Angular's CSP APIs. + */ + this.embedLinkedStylesheetOverride = async (link, document) => { + const returnValue = await this.initialEmbedLinkedStylesheet(link, document); + const cspNonce = this.findCspNonce(document); + if (cspNonce) { + const crittersMedia = link.getAttribute('onload')?.match(MEDIA_SET_HANDLER_PATTERN); + if (crittersMedia) { + // If there's a Critters-generated `onload` handler and the file has an Angular CSP nonce, + // we have to remove the handler, because it's incompatible with CSP. We save the value + // in a different attribute and we generate a script tag with the nonce that uses + // `addEventListener` to apply the media query instead. + link.removeAttribute('onload'); + link.setAttribute(CSP_MEDIA_ATTR, crittersMedia[1]); + this.conditionallyInsertCspLoadingScript(document, cspNonce); + } + link.prev?.setAttribute('nonce', cspNonce); + } + return returnValue; + }; + // We can't use inheritance to override `embedLinkedStylesheet`, because it's not declared in + // the `Critters` .d.ts which means that we can't call the `super` implementation. TS doesn't + // allow for `super` to be cast to a different type. + this.initialEmbedLinkedStylesheet = this.embedLinkedStylesheet; + this.embedLinkedStylesheet = this.embedLinkedStylesheetOverride; + } + readFile(path) { + const readAsset = this.optionsExtended.readAsset; + return readAsset ? readAsset(path) : fs.promises.readFile(path, 'utf-8'); + } + /** + * Finds the CSP nonce for a specific document. + */ + findCspNonce(document) { + if (this.documentNonces.has(document)) { + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + return this.documentNonces.get(document); + } + // HTML attribute are case-insensitive, but the parser used by Critters is case-sensitive. + const nonceElement = document.querySelector('[ngCspNonce], [ngcspnonce]'); + const cspNonce = nonceElement?.getAttribute('ngCspNonce') || nonceElement?.getAttribute('ngcspnonce') || null; + this.documentNonces.set(document, cspNonce); + return cspNonce; + } + /** + * Inserts the `script` tag that swaps the critical CSS at runtime, + * if one hasn't been inserted into the document already. + */ + conditionallyInsertCspLoadingScript(document, nonce) { + if (this.addedCspScriptsDocuments.has(document)) { + return; + } + const script = document.createElement('script'); + script.setAttribute('nonce', nonce); + script.textContent = LINK_LOAD_SCRIPT_CONTENT; + // Append the script to the head since it needs to + // run as early as possible, after the `link` tags. + document.head.appendChild(script); + this.addedCspScriptsDocuments.add(document); + } +} +class InlineCriticalCssProcessor { + constructor(options) { + this.options = options; + } + async process(html, options) { + const critters = new CrittersExtended({ ...this.options, ...options }); + const content = await critters.process(html); + return { + // Clean up value from value less attributes. + // This is caused because parse5 always requires attributes to have a string value. + // nomodule="" defer="" -> nomodule defer. + content: content.replace(/(\s(?:defer|nomodule))=""/g, '$1'), + errors: critters.errors, + warnings: critters.warnings, + }; + } +} +exports.InlineCriticalCssProcessor = InlineCriticalCssProcessor; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"inline-critical-css.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/utils/index-file/inline-critical-css.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 * as fs from 'fs';\n\nconst Critters: typeof import('critters').default = require('critters');\n\n/**\n * Pattern used to extract the media query set by Critters in an `onload` handler.\n */\nconst MEDIA_SET_HANDLER_PATTERN = /^this\\.media=[\"'](.*)[\"'];?$/;\n\n/**\n * Name of the attribute used to save the Critters media query so it can be re-assigned on load.\n */\nconst CSP_MEDIA_ATTR = 'ngCspMedia';\n\n/**\n * Script text used to change the media value of the link tags.\n */\nconst LINK_LOAD_SCRIPT_CONTENT = [\n  `(() => {`,\n  // Save the `children` in a variable since they're a live DOM node collection.\n  // We iterate over the direct descendants, instead of going through a `querySelectorAll`,\n  // because we know that the tags will be directly inside the `head`.\n  `  const children = document.head.children;`,\n  // Declare `onLoad` outside the loop to avoid leaking memory.\n  // Can't be an arrow function, because we need `this` to refer to the DOM node.\n  `  function onLoad() {this.media = this.getAttribute('${CSP_MEDIA_ATTR}');}`,\n  // Has to use a plain for loop, because some browsers don't support\n  // `forEach` on `children` which is a `HTMLCollection`.\n  `  for (let i = 0; i < children.length; i++) {`,\n  `    const child = children[i];`,\n  `    child.hasAttribute('${CSP_MEDIA_ATTR}') && child.addEventListener('load', onLoad);`,\n  `  }`,\n  `})();`,\n].join('\\n');\n\nexport interface InlineCriticalCssProcessOptions {\n  outputPath: string;\n}\n\nexport interface InlineCriticalCssProcessorOptions {\n  minify?: boolean;\n  deployUrl?: string;\n  readAsset?: (path: string) => Promise<string>;\n}\n\n/** Partial representation of an `HTMLElement`. */\ninterface PartialHTMLElement {\n  getAttribute(name: string): string | null;\n  setAttribute(name: string, value: string): void;\n  hasAttribute(name: string): boolean;\n  removeAttribute(name: string): void;\n  appendChild(child: PartialHTMLElement): void;\n  textContent: string;\n  tagName: string | null;\n  children: PartialHTMLElement[];\n  next: PartialHTMLElement | null;\n  prev: PartialHTMLElement | null;\n}\n\n/** Partial representation of an HTML `Document`. */\ninterface PartialDocument {\n  head: PartialHTMLElement;\n  createElement(tagName: string): PartialHTMLElement;\n  querySelector(selector: string): PartialHTMLElement | null;\n}\n\n/** Signature of the `Critters.embedLinkedStylesheet` method. */\ntype EmbedLinkedStylesheetFn = (\n  link: PartialHTMLElement,\n  document: PartialDocument,\n) => Promise<unknown>;\n\nclass CrittersExtended extends Critters {\n  readonly warnings: string[] = [];\n  readonly errors: string[] = [];\n  private initialEmbedLinkedStylesheet: EmbedLinkedStylesheetFn;\n  private addedCspScriptsDocuments = new WeakSet<PartialDocument>();\n  private documentNonces = new WeakMap<PartialDocument, string | null>();\n\n  // Inherited from `Critters`, but not exposed in the typings.\n  protected embedLinkedStylesheet!: EmbedLinkedStylesheetFn;\n\n  constructor(\n    private readonly optionsExtended: InlineCriticalCssProcessorOptions &\n      InlineCriticalCssProcessOptions,\n  ) {\n    super({\n      logger: {\n        warn: (s: string) => this.warnings.push(s),\n        error: (s: string) => this.errors.push(s),\n        info: () => {},\n      },\n      logLevel: 'warn',\n      path: optionsExtended.outputPath,\n      publicPath: optionsExtended.deployUrl,\n      compress: !!optionsExtended.minify,\n      pruneSource: false,\n      reduceInlineStyles: false,\n      mergeStylesheets: false,\n      // Note: if `preload` changes to anything other than `media`, the logic in\n      // `embedLinkedStylesheetOverride` will have to be updated.\n      preload: 'media',\n      noscriptFallback: true,\n      inlineFonts: true,\n    });\n\n    // We can't use inheritance to override `embedLinkedStylesheet`, because it's not declared in\n    // the `Critters` .d.ts which means that we can't call the `super` implementation. TS doesn't\n    // allow for `super` to be cast to a different type.\n    this.initialEmbedLinkedStylesheet = this.embedLinkedStylesheet;\n    this.embedLinkedStylesheet = this.embedLinkedStylesheetOverride;\n  }\n\n  public override readFile(path: string): Promise<string> {\n    const readAsset = this.optionsExtended.readAsset;\n\n    return readAsset ? readAsset(path) : fs.promises.readFile(path, 'utf-8');\n  }\n\n  /**\n   * Override of the Critters `embedLinkedStylesheet` method\n   * that makes it work with Angular's CSP APIs.\n   */\n  private embedLinkedStylesheetOverride: EmbedLinkedStylesheetFn = async (link, document) => {\n    const returnValue = await this.initialEmbedLinkedStylesheet(link, document);\n    const cspNonce = this.findCspNonce(document);\n\n    if (cspNonce) {\n      const crittersMedia = link.getAttribute('onload')?.match(MEDIA_SET_HANDLER_PATTERN);\n\n      if (crittersMedia) {\n        // If there's a Critters-generated `onload` handler and the file has an Angular CSP nonce,\n        // we have to remove the handler, because it's incompatible with CSP. We save the value\n        // in a different attribute and we generate a script tag with the nonce that uses\n        // `addEventListener` to apply the media query instead.\n        link.removeAttribute('onload');\n        link.setAttribute(CSP_MEDIA_ATTR, crittersMedia[1]);\n        this.conditionallyInsertCspLoadingScript(document, cspNonce);\n      }\n\n      link.prev?.setAttribute('nonce', cspNonce);\n    }\n\n    return returnValue;\n  };\n\n  /**\n   * Finds the CSP nonce for a specific document.\n   */\n  private findCspNonce(document: PartialDocument): string | null {\n    if (this.documentNonces.has(document)) {\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      return this.documentNonces.get(document)!;\n    }\n\n    // HTML attribute are case-insensitive, but the parser used by Critters is case-sensitive.\n    const nonceElement = document.querySelector('[ngCspNonce], [ngcspnonce]');\n    const cspNonce =\n      nonceElement?.getAttribute('ngCspNonce') || nonceElement?.getAttribute('ngcspnonce') || null;\n\n    this.documentNonces.set(document, cspNonce);\n\n    return cspNonce;\n  }\n\n  /**\n   * Inserts the `script` tag that swaps the critical CSS at runtime,\n   * if one hasn't been inserted into the document already.\n   */\n  private conditionallyInsertCspLoadingScript(document: PartialDocument, nonce: string): void {\n    if (this.addedCspScriptsDocuments.has(document)) {\n      return;\n    }\n\n    const script = document.createElement('script');\n    script.setAttribute('nonce', nonce);\n    script.textContent = LINK_LOAD_SCRIPT_CONTENT;\n    // Append the script to the head since it needs to\n    // run as early as possible, after the `link` tags.\n    document.head.appendChild(script);\n    this.addedCspScriptsDocuments.add(document);\n  }\n}\n\nexport class InlineCriticalCssProcessor {\n  constructor(protected readonly options: InlineCriticalCssProcessorOptions) {}\n\n  async process(\n    html: string,\n    options: InlineCriticalCssProcessOptions,\n  ): Promise<{ content: string; warnings: string[]; errors: string[] }> {\n    const critters = new CrittersExtended({ ...this.options, ...options });\n    const content = await critters.process(html);\n\n    return {\n      // Clean up value from value less attributes.\n      // This is caused because parse5 always requires attributes to have a string value.\n      // nomodule=\"\" defer=\"\" -> nomodule defer.\n      content: content.replace(/(\\s(?:defer|nomodule))=\"\"/g, '$1'),\n      errors: critters.errors,\n      warnings: critters.warnings,\n    };\n  }\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/utils/index-file/inline-fonts.d.ts b/artifacts/build-angular/src/utils/index-file/inline-fonts.d.ts new file mode 100644 index 00000000..2a8237a5 --- /dev/null +++ b/artifacts/build-angular/src/utils/index-file/inline-fonts.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 { NormalizedCachedOptions } from '../normalize-cache'; +export interface InlineFontsOptions { + minify?: boolean; + cache?: NormalizedCachedOptions; +} +export declare class InlineFontsProcessor { + private options; + private readonly cachePath; + constructor(options: InlineFontsOptions); + process(content: string): Promise; + private getResponse; + private processHref; + private getFontProviderDetails; + private createNormalizedUrl; +} diff --git a/artifacts/build-angular/src/utils/index-file/inline-fonts.js b/artifacts/build-angular/src/utils/index-file/inline-fonts.js new file mode 100644 index 00000000..ecffcfeb --- /dev/null +++ b/artifacts/build-angular/src/utils/index-file/inline-fonts.js @@ -0,0 +1,226 @@ +"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; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.InlineFontsProcessor = void 0; +const cacache = __importStar(require("cacache")); +const fs = __importStar(require("fs")); +const https = __importStar(require("https")); +const https_proxy_agent_1 = __importDefault(require("https-proxy-agent")); +const path_1 = require("path"); +const url_1 = require("url"); +const package_version_1 = require("../package-version"); +const html_rewriting_stream_1 = require("./html-rewriting-stream"); +const SUPPORTED_PROVIDERS = { + 'fonts.googleapis.com': { + preconnectUrl: 'https://fonts.gstatic.com', + }, + 'use.typekit.net': { + preconnectUrl: 'https://use.typekit.net', + }, +}; +class InlineFontsProcessor { + constructor(options) { + this.options = options; + const { path: cacheDirectory, enabled } = this.options.cache || {}; + if (cacheDirectory && enabled) { + this.cachePath = (0, path_1.join)(cacheDirectory, 'angular-build-fonts'); + } + } + async process(content) { + const hrefList = []; + const existingPreconnect = new Set(); + // Collector link tags with href + const { rewriter: collectorStream, transformedContent: initCollectorStream } = await (0, html_rewriting_stream_1.htmlRewritingStream)(content); + collectorStream.on('startTag', (tag) => { + const { tagName, attrs } = tag; + if (tagName !== 'link') { + return; + } + let hrefValue; + let relValue; + for (const { name, value } of attrs) { + switch (name) { + case 'rel': + relValue = value; + break; + case 'href': + hrefValue = value; + break; + } + if (hrefValue && relValue) { + switch (relValue) { + case 'stylesheet': + // + hrefList.push(hrefValue); + break; + case 'preconnect': + // + existingPreconnect.add(hrefValue.replace(/\/$/, '')); + break; + } + return; + } + } + }); + initCollectorStream().catch(() => { + // We don't really care about any errors here because it just initializes + // the rewriting stream, as we are waiting for `finish` below. + }); + await new Promise((resolve) => collectorStream.on('finish', resolve)); + // Download stylesheets + const hrefsContent = new Map(); + const newPreconnectUrls = new Set(); + for (const hrefItem of hrefList) { + const url = this.createNormalizedUrl(hrefItem); + if (!url) { + continue; + } + const content = await this.processHref(url); + if (content === undefined) { + continue; + } + hrefsContent.set(hrefItem, content); + // Add preconnect + const preconnectUrl = this.getFontProviderDetails(url)?.preconnectUrl; + if (preconnectUrl && !existingPreconnect.has(preconnectUrl)) { + newPreconnectUrls.add(preconnectUrl); + } + } + if (hrefsContent.size === 0) { + return content; + } + // Replace link with style tag. + const { rewriter, transformedContent } = await (0, html_rewriting_stream_1.htmlRewritingStream)(content); + rewriter.on('startTag', (tag) => { + const { tagName, attrs } = tag; + switch (tagName) { + case 'head': + rewriter.emitStartTag(tag); + for (const url of newPreconnectUrls) { + rewriter.emitRaw(``); + } + break; + case 'link': + const hrefAttr = attrs.some(({ name, value }) => name === 'rel' && value === 'stylesheet') && + attrs.find(({ name, value }) => name === 'href' && hrefsContent.has(value)); + if (hrefAttr) { + const href = hrefAttr.value; + const cssContent = hrefsContent.get(href); + rewriter.emitRaw(``); + } + else { + rewriter.emitStartTag(tag); + } + break; + default: + rewriter.emitStartTag(tag); + break; + } + }); + return transformedContent(); + } + async getResponse(url) { + const key = `${package_version_1.VERSION}|${url}`; + if (this.cachePath) { + const entry = await cacache.get.info(this.cachePath, key); + if (entry) { + return fs.promises.readFile(entry.path, 'utf8'); + } + } + let agent; + const httpsProxy = process.env.HTTPS_PROXY ?? process.env.https_proxy; + if (httpsProxy) { + agent = (0, https_proxy_agent_1.default)(httpsProxy); + } + const data = await new Promise((resolve, reject) => { + let rawResponse = ''; + https + .get(url, { + agent, + rejectUnauthorized: false, + headers: { + 'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.121 Safari/537.36', + }, + }, (res) => { + if (res.statusCode !== 200) { + reject(new Error(`Inlining of fonts failed. ${url} returned status code: ${res.statusCode}.`)); + return; + } + res.on('data', (chunk) => (rawResponse += chunk)).on('end', () => resolve(rawResponse)); + }) + .on('error', (e) => reject(new Error(`Inlining of fonts failed. An error has occurred while retrieving ${url} over the internet.\n` + + e.message))); + }); + if (this.cachePath) { + await cacache.put(this.cachePath, key, data); + } + return data; + } + async processHref(url) { + const provider = this.getFontProviderDetails(url); + if (!provider) { + return undefined; + } + let cssContent = await this.getResponse(url); + if (this.options.minify) { + cssContent = cssContent + // Comments. + .replace(/\/\*([\s\S]*?)\*\//g, '') + // New lines. + .replace(/\n/g, '') + // Safe spaces. + .replace(/\s?[{:;]\s+/g, (s) => s.trim()); + } + return cssContent; + } + getFontProviderDetails(url) { + return SUPPORTED_PROVIDERS[url.hostname]; + } + createNormalizedUrl(value) { + // Need to convert '//' to 'https://' because the URL parser will fail with '//'. + const normalizedHref = value.startsWith('//') ? `https:${value}` : value; + if (!normalizedHref.startsWith('http')) { + // Non valid URL. + // Example: relative path styles.css. + return undefined; + } + const url = new url_1.URL(normalizedHref); + // Force HTTPS protocol + url.protocol = 'https:'; + return url; + } +} +exports.InlineFontsProcessor = InlineFontsProcessor; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"inline-fonts.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/utils/index-file/inline-fonts.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,iDAAmC;AACnC,uCAAyB;AACzB,6CAA+B;AAC/B,0EAA2C;AAC3C,+BAA4B;AAC5B,6BAA0B;AAE1B,wDAA6C;AAC7C,mEAA8D;AAW9D,MAAM,mBAAmB,GAAwC;IAC/D,sBAAsB,EAAE;QACtB,aAAa,EAAE,2BAA2B;KAC3C;IACD,iBAAiB,EAAE;QACjB,aAAa,EAAE,yBAAyB;KACzC;CACF,CAAC;AAEF,MAAa,oBAAoB;IAE/B,YAAoB,OAA2B;QAA3B,YAAO,GAAP,OAAO,CAAoB;QAC7C,MAAM,EAAE,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,IAAI,EAAE,CAAC;QACnE,IAAI,cAAc,IAAI,OAAO,EAAE;YAC7B,IAAI,CAAC,SAAS,GAAG,IAAA,WAAI,EAAC,cAAc,EAAE,qBAAqB,CAAC,CAAC;SAC9D;IACH,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,OAAe;QAC3B,MAAM,QAAQ,GAAa,EAAE,CAAC;QAC9B,MAAM,kBAAkB,GAAG,IAAI,GAAG,EAAU,CAAC;QAE7C,gCAAgC;QAChC,MAAM,EAAE,QAAQ,EAAE,eAAe,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,GAC1E,MAAM,IAAA,2CAAmB,EAAC,OAAO,CAAC,CAAC;QAErC,eAAe,CAAC,EAAE,CAAC,UAAU,EAAE,CAAC,GAAG,EAAE,EAAE;YACrC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,GAAG,CAAC;YAE/B,IAAI,OAAO,KAAK,MAAM,EAAE;gBACtB,OAAO;aACR;YAED,IAAI,SAA6B,CAAC;YAClC,IAAI,QAA4B,CAAC;YACjC,KAAK,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,KAAK,EAAE;gBACnC,QAAQ,IAAI,EAAE;oBACZ,KAAK,KAAK;wBACR,QAAQ,GAAG,KAAK,CAAC;wBACjB,MAAM;oBAER,KAAK,MAAM;wBACT,SAAS,GAAG,KAAK,CAAC;wBAClB,MAAM;iBACT;gBAED,IAAI,SAAS,IAAI,QAAQ,EAAE;oBACzB,QAAQ,QAAQ,EAAE;wBAChB,KAAK,YAAY;4BACf,8DAA8D;4BAC9D,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;4BACzB,MAAM;wBAER,KAAK,YAAY;4BACf,qDAAqD;4BACrD,kBAAkB,CAAC,GAAG,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,CAAC;4BACrD,MAAM;qBACT;oBAED,OAAO;iBACR;aACF;QACH,CAAC,CAAC,CAAC;QAEH,mBAAmB,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE;YAC/B,yEAAyE;YACzE,8DAA8D;QAChE,CAAC,CAAC,CAAC;QAEH,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,eAAe,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC;QAEtE,uBAAuB;QACvB,MAAM,YAAY,GAAG,IAAI,GAAG,EAAkB,CAAC;QAC/C,MAAM,iBAAiB,GAAG,IAAI,GAAG,EAAU,CAAC;QAE5C,KAAK,MAAM,QAAQ,IAAI,QAAQ,EAAE;YAC/B,MAAM,GAAG,GAAG,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,CAAC;YAC/C,IAAI,CAAC,GAAG,EAAE;gBACR,SAAS;aACV;YAED,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;YAC5C,IAAI,OAAO,KAAK,SAAS,EAAE;gBACzB,SAAS;aACV;YAED,YAAY,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;YAEpC,iBAAiB;YACjB,MAAM,aAAa,GAAG,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC,EAAE,aAAa,CAAC;YACtE,IAAI,aAAa,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE;gBAC3D,iBAAiB,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;aACtC;SACF;QAED,IAAI,YAAY,CAAC,IAAI,KAAK,CAAC,EAAE;YAC3B,OAAO,OAAO,CAAC;SAChB;QAED,+BAA+B;QAC/B,MAAM,EAAE,QAAQ,EAAE,kBAAkB,EAAE,GAAG,MAAM,IAAA,2CAAmB,EAAC,OAAO,CAAC,CAAC;QAC5E,QAAQ,CAAC,EAAE,CAAC,UAAU,EAAE,CAAC,GAAG,EAAE,EAAE;YAC9B,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,GAAG,CAAC;YAE/B,QAAQ,OAAO,EAAE;gBACf,KAAK,MAAM;oBACT,QAAQ,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;oBAC3B,KAAK,MAAM,GAAG,IAAI,iBAAiB,EAAE;wBACnC,QAAQ,CAAC,OAAO,CAAC,gCAAgC,GAAG,gBAAgB,CAAC,CAAC;qBACvE;oBACD,MAAM;gBAER,KAAK,MAAM;oBACT,MAAM,QAAQ,GACZ,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,IAAI,KAAK,KAAK,IAAI,KAAK,KAAK,YAAY,CAAC;wBACzE,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,IAAI,KAAK,MAAM,IAAI,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;oBAC9E,IAAI,QAAQ,EAAE;wBACZ,MAAM,IAAI,GAAG,QAAQ,CAAC,KAAK,CAAC;wBAC5B,MAAM,UAAU,GAAG,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;wBAC1C,QAAQ,CAAC,OAAO,CAAC,0BAA0B,UAAU,UAAU,CAAC,CAAC;qBAClE;yBAAM;wBACL,QAAQ,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;qBAC5B;oBACD,MAAM;gBAER;oBACE,QAAQ,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;oBAE3B,MAAM;aACT;QACH,CAAC,CAAC,CAAC;QAEH,OAAO,kBAAkB,EAAE,CAAC;IAC9B,CAAC;IAEO,KAAK,CAAC,WAAW,CAAC,GAAQ;QAChC,MAAM,GAAG,GAAG,GAAG,yBAAO,IAAI,GAAG,EAAE,CAAC;QAEhC,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;YAC1D,IAAI,KAAK,EAAE;gBACT,OAAO,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;aACjD;SACF;QAED,IAAI,KAA6C,CAAC;QAClD,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,WAAW,IAAI,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC;QAEtE,IAAI,UAAU,EAAE;YACd,KAAK,GAAG,IAAA,2BAAU,EAAC,UAAU,CAAC,CAAC;SAChC;QAED,MAAM,IAAI,GAAG,MAAM,IAAI,OAAO,CAAS,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACzD,IAAI,WAAW,GAAG,EAAE,CAAC;YACrB,KAAK;iBACF,GAAG,CACF,GAAG,EACH;gBACE,KAAK;gBACL,kBAAkB,EAAE,KAAK;gBACzB,OAAO,EAAE;oBACP,YAAY,EACV,2HAA2H;iBAC9H;aACF,EACD,CAAC,GAAG,EAAE,EAAE;gBACN,IAAI,GAAG,CAAC,UAAU,KAAK,GAAG,EAAE;oBAC1B,MAAM,CACJ,IAAI,KAAK,CACP,6BAA6B,GAAG,0BAA0B,GAAG,CAAC,UAAU,GAAG,CAC5E,CACF,CAAC;oBAEF,OAAO;iBACR;gBAED,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,WAAW,IAAI,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC;YAC1F,CAAC,CACF;iBACA,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,EAAE,CACjB,MAAM,CACJ,IAAI,KAAK,CACP,oEAAoE,GAAG,uBAAuB;gBAC5F,CAAC,CAAC,OAAO,CACZ,CACF,CACF,CAAC;QACN,CAAC,CAAC,CAAC;QAEH,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,MAAM,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;SAC9C;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,KAAK,CAAC,WAAW,CAAC,GAAQ;QAChC,MAAM,QAAQ,GAAG,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC,CAAC;QAClD,IAAI,CAAC,QAAQ,EAAE;YACb,OAAO,SAAS,CAAC;SAClB;QAED,IAAI,UAAU,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QAE7C,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;YACvB,UAAU,GAAG,UAAU;gBACrB,YAAY;iBACX,OAAO,CAAC,qBAAqB,EAAE,EAAE,CAAC;gBACnC,aAAa;iBACZ,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC;gBACnB,eAAe;iBACd,OAAO,CAAC,cAAc,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;SAC7C;QAED,OAAO,UAAU,CAAC;IACpB,CAAC;IAEO,sBAAsB,CAAC,GAAQ;QACrC,OAAO,mBAAmB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC3C,CAAC;IAEO,mBAAmB,CAAC,KAAa;QACvC,iFAAiF;QACjF,MAAM,cAAc,GAAG,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;QACzE,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE;YACtC,iBAAiB;YACjB,qCAAqC;YACrC,OAAO,SAAS,CAAC;SAClB;QAED,MAAM,GAAG,GAAG,IAAI,SAAG,CAAC,cAAc,CAAC,CAAC;QACpC,uBAAuB;QACvB,GAAG,CAAC,QAAQ,GAAG,QAAQ,CAAC;QAExB,OAAO,GAAG,CAAC;IACb,CAAC;CACF;AAnOD,oDAmOC","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 * as cacache from 'cacache';\nimport * as fs from 'fs';\nimport * as https from 'https';\nimport proxyAgent from 'https-proxy-agent';\nimport { join } from 'path';\nimport { URL } from 'url';\nimport { NormalizedCachedOptions } from '../normalize-cache';\nimport { VERSION } from '../package-version';\nimport { htmlRewritingStream } from './html-rewriting-stream';\n\ninterface FontProviderDetails {\n  preconnectUrl: string;\n}\n\nexport interface InlineFontsOptions {\n  minify?: boolean;\n  cache?: NormalizedCachedOptions;\n}\n\nconst SUPPORTED_PROVIDERS: Record<string, FontProviderDetails> = {\n  'fonts.googleapis.com': {\n    preconnectUrl: 'https://fonts.gstatic.com',\n  },\n  'use.typekit.net': {\n    preconnectUrl: 'https://use.typekit.net',\n  },\n};\n\nexport class InlineFontsProcessor {\n  private readonly cachePath: string | undefined;\n  constructor(private options: InlineFontsOptions) {\n    const { path: cacheDirectory, enabled } = this.options.cache || {};\n    if (cacheDirectory && enabled) {\n      this.cachePath = join(cacheDirectory, 'angular-build-fonts');\n    }\n  }\n\n  async process(content: string): Promise<string> {\n    const hrefList: string[] = [];\n    const existingPreconnect = new Set<string>();\n\n    // Collector link tags with href\n    const { rewriter: collectorStream, transformedContent: initCollectorStream } =\n      await htmlRewritingStream(content);\n\n    collectorStream.on('startTag', (tag) => {\n      const { tagName, attrs } = tag;\n\n      if (tagName !== 'link') {\n        return;\n      }\n\n      let hrefValue: string | undefined;\n      let relValue: string | undefined;\n      for (const { name, value } of attrs) {\n        switch (name) {\n          case 'rel':\n            relValue = value;\n            break;\n\n          case 'href':\n            hrefValue = value;\n            break;\n        }\n\n        if (hrefValue && relValue) {\n          switch (relValue) {\n            case 'stylesheet':\n              // <link rel=\"stylesheet\" href=\"https://example.com/main.css\">\n              hrefList.push(hrefValue);\n              break;\n\n            case 'preconnect':\n              // <link rel=\"preconnect\" href=\"https://example.com\">\n              existingPreconnect.add(hrefValue.replace(/\\/$/, ''));\n              break;\n          }\n\n          return;\n        }\n      }\n    });\n\n    initCollectorStream().catch(() => {\n      // We don't really care about any errors here because it just initializes\n      // the rewriting stream, as we are waiting for `finish` below.\n    });\n\n    await new Promise((resolve) => collectorStream.on('finish', resolve));\n\n    // Download stylesheets\n    const hrefsContent = new Map<string, string>();\n    const newPreconnectUrls = new Set<string>();\n\n    for (const hrefItem of hrefList) {\n      const url = this.createNormalizedUrl(hrefItem);\n      if (!url) {\n        continue;\n      }\n\n      const content = await this.processHref(url);\n      if (content === undefined) {\n        continue;\n      }\n\n      hrefsContent.set(hrefItem, content);\n\n      // Add preconnect\n      const preconnectUrl = this.getFontProviderDetails(url)?.preconnectUrl;\n      if (preconnectUrl && !existingPreconnect.has(preconnectUrl)) {\n        newPreconnectUrls.add(preconnectUrl);\n      }\n    }\n\n    if (hrefsContent.size === 0) {\n      return content;\n    }\n\n    // Replace link with style tag.\n    const { rewriter, transformedContent } = await htmlRewritingStream(content);\n    rewriter.on('startTag', (tag) => {\n      const { tagName, attrs } = tag;\n\n      switch (tagName) {\n        case 'head':\n          rewriter.emitStartTag(tag);\n          for (const url of newPreconnectUrls) {\n            rewriter.emitRaw(`<link rel=\"preconnect\" href=\"${url}\" crossorigin>`);\n          }\n          break;\n\n        case 'link':\n          const hrefAttr =\n            attrs.some(({ name, value }) => name === 'rel' && value === 'stylesheet') &&\n            attrs.find(({ name, value }) => name === 'href' && hrefsContent.has(value));\n          if (hrefAttr) {\n            const href = hrefAttr.value;\n            const cssContent = hrefsContent.get(href);\n            rewriter.emitRaw(`<style type=\"text/css\">${cssContent}</style>`);\n          } else {\n            rewriter.emitStartTag(tag);\n          }\n          break;\n\n        default:\n          rewriter.emitStartTag(tag);\n\n          break;\n      }\n    });\n\n    return transformedContent();\n  }\n\n  private async getResponse(url: URL): Promise<string> {\n    const key = `${VERSION}|${url}`;\n\n    if (this.cachePath) {\n      const entry = await cacache.get.info(this.cachePath, key);\n      if (entry) {\n        return fs.promises.readFile(entry.path, 'utf8');\n      }\n    }\n\n    let agent: proxyAgent.HttpsProxyAgent | undefined;\n    const httpsProxy = process.env.HTTPS_PROXY ?? process.env.https_proxy;\n\n    if (httpsProxy) {\n      agent = proxyAgent(httpsProxy);\n    }\n\n    const data = await new Promise<string>((resolve, reject) => {\n      let rawResponse = '';\n      https\n        .get(\n          url,\n          {\n            agent,\n            rejectUnauthorized: false,\n            headers: {\n              'user-agent':\n                'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.121 Safari/537.36',\n            },\n          },\n          (res) => {\n            if (res.statusCode !== 200) {\n              reject(\n                new Error(\n                  `Inlining of fonts failed. ${url} returned status code: ${res.statusCode}.`,\n                ),\n              );\n\n              return;\n            }\n\n            res.on('data', (chunk) => (rawResponse += chunk)).on('end', () => resolve(rawResponse));\n          },\n        )\n        .on('error', (e) =>\n          reject(\n            new Error(\n              `Inlining of fonts failed. An error has occurred while retrieving ${url} over the internet.\\n` +\n                e.message,\n            ),\n          ),\n        );\n    });\n\n    if (this.cachePath) {\n      await cacache.put(this.cachePath, key, data);\n    }\n\n    return data;\n  }\n\n  private async processHref(url: URL): Promise<string | undefined> {\n    const provider = this.getFontProviderDetails(url);\n    if (!provider) {\n      return undefined;\n    }\n\n    let cssContent = await this.getResponse(url);\n\n    if (this.options.minify) {\n      cssContent = cssContent\n        // Comments.\n        .replace(/\\/\\*([\\s\\S]*?)\\*\\//g, '')\n        // New lines.\n        .replace(/\\n/g, '')\n        // Safe spaces.\n        .replace(/\\s?[{:;]\\s+/g, (s) => s.trim());\n    }\n\n    return cssContent;\n  }\n\n  private getFontProviderDetails(url: URL): FontProviderDetails | undefined {\n    return SUPPORTED_PROVIDERS[url.hostname];\n  }\n\n  private createNormalizedUrl(value: string): URL | undefined {\n    // Need to convert '//' to 'https://' because the URL parser will fail with '//'.\n    const normalizedHref = value.startsWith('//') ? `https:${value}` : value;\n    if (!normalizedHref.startsWith('http')) {\n      // Non valid URL.\n      // Example: relative path styles.css.\n      return undefined;\n    }\n\n    const url = new URL(normalizedHref);\n    // Force HTTPS protocol\n    url.protocol = 'https:';\n\n    return url;\n  }\n}\n"]} \ No newline at end of file diff --git a/artifacts/build-angular/src/utils/index-file/style-nonce.d.ts b/artifacts/build-angular/src/utils/index-file/style-nonce.d.ts new file mode 100644 index 00000000..10ab0734 --- /dev/null +++ b/artifacts/build-angular/src/utils/index-file/style-nonce.d.ts @@ -0,0 +1,12 @@ +/** + * @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 + */ +/** + * Finds the `ngCspNonce` value and copies it to all inline `