b54ed980ed
NgModules in Ivy have a definition which contains various different bits of metadata about the module. In particular, this metadata falls into two categories: * metadata required to use the module at runtime (for bootstrapping, etc) in AOT-only applications. * metadata required to depend on the module from a JIT-compiled app. The latter metadata consists of the module's declarations, imports, and exports. To support JIT usage, this metadata must be included in the generated code, especially if that code is shipped to NPM. However, because this metadata preserves the entire NgModule graph (references to all directives and components in the app), it needs to be removed during optimization for AOT-only builds. Previously, this was done with a clever design: 1. The extra metadata was added by a function called `setNgModuleScope`. A call to this function was generated after each NgModule. 2. This function call was marked as "pure" with a comment and used `noSideEffects` internally, which causes optimizers to remove it. The effect was that in dev mode or test mode (which use JIT), no optimizer runs and the full NgModule metadata was available at runtime. But in production (presumably AOT) builds, the optimizer runs and removes the JIT- specific metadata. However, there are cases where apps that want to use JIT in production, and still make an optimized build. In this case, the JIT-specific metadata would be erroneously removed. This commit solves that problem by adding an `ngJitMode` global variable which guards all `setNgModuleScope` calls. An optimizer can be configured to statically define this global to be `false` for AOT-only builds, causing the extra metadata to be stripped. A configuration for Terser used by the CLI is provided in `tooling.ts` which sets `ngJitMode` to `false` when building AOT apps. PR Close #33671
101 lines
3.2 KiB
TypeScript
101 lines
3.2 KiB
TypeScript
/**
|
|
* @license
|
|
* Copyright Google Inc. 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 {StaticSymbol} from '../aot/static_symbol';
|
|
import * as o from '../output/output_ast';
|
|
import {OutputContext} from '../util';
|
|
|
|
/**
|
|
* Convert an object map with `Expression` values into a `LiteralMapExpr`.
|
|
*/
|
|
export function mapToMapExpression(map: {[key: string]: o.Expression | undefined}):
|
|
o.LiteralMapExpr {
|
|
const result = Object.keys(map).map(
|
|
key => ({
|
|
key,
|
|
// The assertion here is because really TypeScript doesn't allow us to express that if the
|
|
// key is present, it will have a value, but this is true in reality.
|
|
value: map[key] !,
|
|
quoted: false,
|
|
}));
|
|
return o.literalMap(result);
|
|
}
|
|
|
|
/**
|
|
* Convert metadata into an `Expression` in the given `OutputContext`.
|
|
*
|
|
* This operation will handle arrays, references to symbols, or literal `null` or `undefined`.
|
|
*/
|
|
export function convertMetaToOutput(meta: any, ctx: OutputContext): o.Expression {
|
|
if (Array.isArray(meta)) {
|
|
return o.literalArr(meta.map(entry => convertMetaToOutput(entry, ctx)));
|
|
}
|
|
if (meta instanceof StaticSymbol) {
|
|
return ctx.importExpr(meta);
|
|
}
|
|
if (meta == null) {
|
|
return o.literal(meta);
|
|
}
|
|
|
|
throw new Error(`Internal error: Unsupported or unknown metadata: ${meta}`);
|
|
}
|
|
|
|
export function typeWithParameters(type: o.Expression, numParams: number): o.ExpressionType {
|
|
let params: o.Type[]|null = null;
|
|
if (numParams > 0) {
|
|
params = [];
|
|
for (let i = 0; i < numParams; i++) {
|
|
params.push(o.DYNAMIC_TYPE);
|
|
}
|
|
}
|
|
return o.expressionType(type, null, params);
|
|
}
|
|
|
|
export interface R3Reference {
|
|
value: o.Expression;
|
|
type: o.Expression;
|
|
}
|
|
|
|
const ANIMATE_SYMBOL_PREFIX = '@';
|
|
export function prepareSyntheticPropertyName(name: string) {
|
|
return `${ANIMATE_SYMBOL_PREFIX}${name}`;
|
|
}
|
|
|
|
export function prepareSyntheticListenerName(name: string, phase: string) {
|
|
return `${ANIMATE_SYMBOL_PREFIX}${name}.${phase}`;
|
|
}
|
|
|
|
export function isSyntheticPropertyOrListener(name: string) {
|
|
return name.charAt(0) == ANIMATE_SYMBOL_PREFIX;
|
|
}
|
|
|
|
export function getSyntheticPropertyName(name: string) {
|
|
// this will strip out listener phase values...
|
|
// @foo.start => @foo
|
|
const i = name.indexOf('.');
|
|
name = i > 0 ? name.substring(0, i) : name;
|
|
if (name.charAt(0) !== ANIMATE_SYMBOL_PREFIX) {
|
|
name = ANIMATE_SYMBOL_PREFIX + name;
|
|
}
|
|
return name;
|
|
}
|
|
|
|
export function prepareSyntheticListenerFunctionName(name: string, phase: string) {
|
|
return `animation_${name}_${phase}`;
|
|
}
|
|
|
|
export function jitOnlyGuardedExpression(expr: o.Expression): o.Expression {
|
|
const ngJitMode = new o.ExternalExpr({name: 'ngJitMode', moduleName: null});
|
|
const jitFlagNotDefined = new o.BinaryOperatorExpr(
|
|
o.BinaryOperator.Identical, new o.TypeofExpr(ngJitMode), o.literal('undefined'));
|
|
const jitFlagUndefinedOrTrue = new o.BinaryOperatorExpr(
|
|
o.BinaryOperator.Or, jitFlagNotDefined, ngJitMode, /* type */ undefined,
|
|
/* sourceSpan */ undefined, true);
|
|
return new o.BinaryOperatorExpr(o.BinaryOperator.And, jitFlagUndefinedOrTrue, expr);
|
|
}
|