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]); });