registry.forEach(function (value, key) {
var keyLiteral = o.literal(key);
exprs.push(keyLiteral);
var initialValue = initialValues[key];
if (initialValue) {
nameAndValueExprs.push(keyLiteral, o.literal(initialValue));
}
});
buildParams: function (convertFn) {
var params = [_this._elementIndexExpr, o.literal(bindingIndex), convertFn(value)];
if (allowUnits) {
if (input.unit) {
params.push(o.literal(input.unit));
}
else if (_this._directiveIndexExpr) {
params.push(o.NULL_EXPR);
}
}
if (_this._directiveIndexExpr) {
params.push(_this._directiveIndexExpr);
}
return params;
}
function compileInjectDependency(dep, injectFn) {
// Interpret the dependency according to its resolved type.
switch (dep.resolved) {
case R3ResolvedDependencyType.Token: {
// Build up the injection flags according to the metadata.
var flags = 0 /* Default */ | (dep.self ? 2 /* Self */ : 0) |
(dep.skipSelf ? 4 /* SkipSelf */ : 0) | (dep.host ? 1 /* Host */ : 0) |
(dep.optional ? 8 /* Optional */ : 0);
// Build up the arguments to the injectFn call.
var injectArgs = [dep.token];
// If this dependency is optional or otherwise has non-default flags, then additional
// parameters describing how to inject the dependency must be passed to the inject function
// that's being used.
if (flags !== 0 /* Default */ || dep.optional) {
injectArgs.push(o.literal(flags));
}
return o.importExpr(injectFn).callFn(injectArgs);
}
case R3ResolvedDependencyType.Attribute:
// In the case of attributes, the attribute name in question is given as the token.
return o.importExpr(r3_identifiers_1.Identifiers.injectAttribute).callFn([dep.token]);
default:
return util_1.unsupported("Unknown R3ResolvedDependencyType: " + R3ResolvedDependencyType[dep.resolved]);
}
}
NgModuleCompiler.prototype.compile = function (ctx, ngModuleMeta, extraProviders) {
var sourceSpan = parse_util_1.typeSourceSpan('NgModule', ngModuleMeta.type);
var entryComponentFactories = ngModuleMeta.transitiveModule.entryComponents;
var bootstrapComponents = ngModuleMeta.bootstrapComponents;
var providerParser = new provider_analyzer_1.NgModuleProviderAnalyzer(this.reflector, ngModuleMeta, extraProviders, sourceSpan);
var providerDefs = [provider_compiler_1.componentFactoryResolverProviderDef(this.reflector, ctx, 0 /* None */, entryComponentFactories)]
.concat(providerParser.parse().map(function (provider) { return provider_compiler_1.providerDef(ctx, provider); }))
.map(function (_a) {
var providerExpr = _a.providerExpr, depsExpr = _a.depsExpr, flags = _a.flags, tokenExpr = _a.tokenExpr;
return o.importExpr(identifiers_1.Identifiers.moduleProviderDef).callFn([
o.literal(flags), tokenExpr, providerExpr, depsExpr
]);
});
var ngModuleDef = o.importExpr(identifiers_1.Identifiers.moduleDef).callFn([o.literalArr(providerDefs)]);
var ngModuleDefFactory = o.fn([new o.FnParam(LOG_VAR.name)], [new o.ReturnStatement(ngModuleDef)], o.INFERRED_TYPE);
var ngModuleFactoryVar = compile_metadata_1.identifierName(ngModuleMeta.type) + "NgFactory";
this._createNgModuleFactory(ctx, ngModuleMeta.type.reference, o.importExpr(identifiers_1.Identifiers.createModuleFactory).callFn([
ctx.importExpr(ngModuleMeta.type.reference),
o.literalArr(bootstrapComponents.map(function (id) { return ctx.importExpr(id.reference); })),
ngModuleDefFactory
]));
if (ngModuleMeta.id) {
var id = typeof ngModuleMeta.id === 'string' ? o.literal(ngModuleMeta.id) :
ctx.importExpr(ngModuleMeta.id);
var registerFactoryStmt = o.importExpr(identifiers_1.Identifiers.RegisterModuleFactoryFn)
.callFn([id, o.variable(ngModuleFactoryVar)])
.toStmt();
ctx.statements.push(registerFactoryStmt);
}
return new NgModuleCompileResult(ngModuleFactoryVar);
};
function i18nTranslationToDeclStmt(variable, message, params) {
var args = [o.literal(message)];
if (params && Object.keys(params).length) {
args.push(map_util_1.mapLiteral(params, true));
}
var fnCall = o.variable(GOOG_GET_MSG).callFn(args);
return variable.set(fnCall).toDeclStmt(o.INFERRED_TYPE, [o.StmtModifier.Final]);
}
/**
* Convert metadata into an `Expression` in the given `OutputContext`.
*
* This operation will handle arrays, references to symbols, or literal `null` or `undefined`.
*/
function convertMetaToOutput(meta, ctx) {
if (Array.isArray(meta)) {
return o.literalArr(meta.map(function (entry) { return convertMetaToOutput(entry, ctx); }));
}
if (meta instanceof static_symbol_1.StaticSymbol) {
return ctx.importExpr(meta);
}
if (meta == null) {
return o.literal(meta);
}
throw new Error("Internal error: Unsupported or unknown metadata: " + meta);
}
function compilePipeFromMetadata(metadata) {
var definitionMapValues = [];
// e.g. `name: 'myPipe'`
definitionMapValues.push({ key: 'name', value: o.literal(metadata.pipeName), quoted: false });
// e.g. `type: MyPipe`
definitionMapValues.push({ key: 'type', value: metadata.type, quoted: false });
var templateFactory = r3_factory_1.compileFactoryFunction({
name: metadata.name,
type: metadata.type,
deps: metadata.deps,
injectFn: r3_identifiers_1.Identifiers.directiveInject,
});
definitionMapValues.push({ key: 'factory', value: templateFactory.factory, quoted: false });
// e.g. `pure: true`
definitionMapValues.push({ key: 'pure', value: o.literal(metadata.pure), quoted: false });
var expression = o.importExpr(r3_identifiers_1.Identifiers.definePipe).callFn([o.literalMap(definitionMapValues)]);
var type = new o.ExpressionType(o.importExpr(r3_identifiers_1.Identifiers.PipeDefWithMeta, [
util_2.typeWithParameters(metadata.type, metadata.typeArgumentCount),
new o.ExpressionType(new o.LiteralExpr(metadata.pipeName)),
]));
return { expression: expression, type: type, statements: templateFactory.statements };
}
function depDef(ctx, dep) {
// Note: the following fields have already been normalized out by provider_analyzer:
// - isAttribute, isHost
var expr = dep.isValue ? value_util_1.convertValueToOutputAst(ctx, dep.value) : tokenExpr(ctx, dep.token);
var flags = 0 /* None */;
if (dep.isSkipSelf) {
flags |= 1 /* SkipSelf */;
}
if (dep.isOptional) {
flags |= 2 /* Optional */;
}
if (dep.isSelf) {
flags |= 4 /* Self */;
}
if (dep.isValue) {
flags |= 8 /* Value */;
}
return flags === 0 /* None */ ? expr : o.literalArr([o.literal(flags), expr]);
}
StylingBuilder.prototype._buildInitExpr = function (registry, initialValues) {
var exprs = [];
var nameAndValueExprs = [];
// _c0 = [prop, prop2, prop3, ...]
registry.forEach(function (value, key) {
var keyLiteral = o.literal(key);
exprs.push(keyLiteral);
var initialValue = initialValues[key];
if (initialValue) {
nameAndValueExprs.push(keyLiteral, o.literal(initialValue));
}
});
if (nameAndValueExprs.length) {
// _c0 = [... MARKER ...]
exprs.push(o.literal(1 /* VALUES_MODE */));
// _c0 = [prop, VALUE, prop2, VALUE2, ...]
exprs.push.apply(exprs, tslib_1.__spread(nameAndValueExprs));
}
return exprs.length ? o.literalArr(exprs) : null;
};
function i18nTranslationToDeclStmt(variable, closureVar, message, meta, params) {
var statements = [];
// var I18N_X;
statements.push(new o.DeclareVarStmt(variable.name, undefined, o.INFERRED_TYPE, null, variable.sourceSpan));
var args = [o.literal(message)];
if (params && Object.keys(params).length) {
args.push(map_util_1.mapLiteral(params, true));
}
// Closure JSDoc comments
var docStatements = i18nMetaToDocStmt(meta);
var thenStatements = docStatements ? [docStatements] : [];
var googFnCall = o.variable(GOOG_GET_MSG).callFn(args);
// const MSG_... = goog.getMsg(..);
thenStatements.push(closureVar.set(googFnCall).toConstDecl());
// I18N_X = MSG_...;
thenStatements.push(new o.ExpressionStatement(variable.set(closureVar)));
var localizeFnCall = o.importExpr(r3_identifiers_1.Identifiers.i18nLocalize).callFn(args);
// I18N_X = i18nLocalize(...);
var elseStatements = [new o.ExpressionStatement(variable.set(localizeFnCall))];
// if(ngI18nClosureMode) { ... } else { ... }
statements.push(o.ifStmt(o.variable(NG_I18N_CLOSURE_MODE), thenStatements, elseStatements));
return statements;
}
function asLiteral(value) {
if (Array.isArray(value)) {
return o.literalArr(value.map(asLiteral));
}
return o.literal(value, o.INFERRED_TYPE);
}
_ValueOutputAstTransformer.prototype.visitPrimitive = function (value, type) { return o.literal(value, type); };
var expressionForKey = o.literalMap(literal.entries.map(function (e) { return ({
key: e.key,
value: e.value.isConstant() ? e.value : o.literal(null),
quoted: e.quoted
}); }));
var argumentsForKey = literal.entries.map(function (e) { return e.isConstant() ? e : o.literal(null); });
ConstantPool.prototype.getTranslationDeclStmt = function (variable, message) {
var fnCall = o.variable(GOOG_GET_MSG).callFn([o.literal(message)]);
return variable.set(fnCall).toDeclStmt(o.INFERRED_TYPE, [o.StmtModifier.Final]);
};
.map(function (_a) {
var providerExpr = _a.providerExpr, depsExpr = _a.depsExpr, flags = _a.flags, tokenExpr = _a.tokenExpr;
return o.importExpr(identifiers_1.Identifiers.moduleProviderDef).callFn([
o.literal(flags), tokenExpr, providerExpr, depsExpr
]);
});
var styleExpressions = stylesheet.styles.map(function (plainStyle) { return o.literal(_this._shimIfNeeded(plainStyle, shim)); });
/**
* A helper function useful for extracting `R3DependencyMetadata` from a Render2
* `CompileTypeMetadata` instance.
*/
function dependenciesFromGlobalMetadata(type, outputCtx, reflector) {
var e_1, _a;
// Use the `CompileReflector` to look up references to some well-known Angular types. These will
// be compared with the token to statically determine whether the token has significance to
// Angular, and set the correct `R3ResolvedDependencyType` as a result.
var injectorRef = reflector.resolveExternalReference(identifiers_1.Identifiers.Injector);
// Iterate through the type's DI dependencies and produce `R3DependencyMetadata` for each of them.
var deps = [];
try {
for (var _b = tslib_1.__values(type.diDeps), _c = _b.next(); !_c.done; _c = _b.next()) {
var dependency = _c.value;
if (dependency.token) {
var tokenRef = compile_metadata_1.tokenReference(dependency.token);
var resolved = dependency.isAttribute ?
R3ResolvedDependencyType.Attribute :
R3ResolvedDependencyType.Token;
// In the case of most dependencies, the token will be a reference to a type. Sometimes,
// however, it can be a string, in the case of older Angular code or @Attribute injection.
var token = tokenRef instanceof static_symbol_1.StaticSymbol ? outputCtx.importExpr(tokenRef) : o.literal(tokenRef);
// Construct the dependency.
deps.push({
token: token,
resolved: resolved,
host: !!dependency.isHost,
optional: !!dependency.isOptional,
self: !!dependency.isSelf,
skipSelf: !!dependency.isSkipSelf,
});
}
else {
util_1.unsupported('dependency without a token');
}
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_1) throw e_1.error; }
}
return deps;
}
var selectors = selector.split(',').map(function (token) { return o.literal(token.trim()); });
function tokenExpr(ctx, tokenMeta) {
return tokenMeta.identifier ? ctx.importExpr(tokenMeta.identifier.reference) :
o.literal(tokenMeta.value);
}
placeholders.forEach(function (values, key) {
params[key] = o.literal(values.length > 1 ? "[" + values.join('|') + "]" : values[0]);
});