Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
NgModuleDecoratorHandler.prototype.analyze = function (node, decorator) {
var _this = this;
var _a, _b, _c, _d;
if (decorator.args === null || decorator.args.length > 1) {
throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_ARITY_WRONG, decorator.node, "Incorrect number of arguments to @NgModule decorator");
}
// @NgModule can be invoked without arguments. In case it is, pretend as if a blank object
// literal was specified. This simplifies the code below.
var meta = decorator.args.length === 1 ? util_1.unwrapExpression(decorator.args[0]) :
ts.createObjectLiteral([]);
if (!ts.isObjectLiteralExpression(meta)) {
throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_ARG_NOT_LITERAL, meta, '@NgModule argument must be an object literal');
}
var ngModule = metadata_1.reflectObjectLiteral(meta);
if (ngModule.has('jit')) {
// The only allowed value is true, so there's no need to expand further.
return {};
}
// Extract the module declarations, imports, and exports.
var declarations = [];
if (ngModule.has('declarations')) {
var expr = ngModule.get('declarations');
var declarationMeta = metadata_1.staticallyResolve(expr, this.reflector, this.checker);
declarations = this.resolveTypeList(expr, declarationMeta, 'declarations');
(_a = this.referencesRegistry).add.apply(_a, tslib_1.__spread(declarations));
}
var imports = [];
if (ngModule.has('imports')) {
var expr = ngModule.get('imports');
var importsMeta = metadata_1.staticallyResolve(expr, this.reflector, this.checker, function (ref) { return _this._extractModuleFromModuleWithProvidersFn(ref.node); });
name: name,
type: type,
typeArgumentCount: typeArgumentCount,
providedIn: new compiler_1.LiteralExpr(null), ctorDeps: ctorDeps,
};
}
else if (decorator.args.length === 1) {
var metaNode = decorator.args[0];
// Firstly make sure the decorator argument is an inline literal - if not, it's illegal to
// transport references from one location to another. This is the problem that lowering
// used to solve - if this restriction proves too undesirable we can re-implement lowering.
if (!ts.isObjectLiteralExpression(metaNode)) {
throw new Error("In Ivy, decorator metadata must be inline.");
}
// Resolve the fields of the literal into a map of field name to expression.
var meta = metadata_1.reflectObjectLiteral(metaNode);
var providedIn = new compiler_1.LiteralExpr(null);
if (meta.has('providedIn')) {
providedIn = new compiler_1.WrappedNodeExpr(meta.get('providedIn'));
}
var userDeps = undefined;
if ((meta.has('useClass') || meta.has('useFactory')) && meta.has('deps')) {
var depsExpr = meta.get('deps');
if (!ts.isArrayLiteralExpression(depsExpr)) {
throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.VALUE_NOT_LITERAL, depsExpr, "In Ivy, deps metadata must be an inline array.");
}
if (depsExpr.elements.length > 0) {
throw new Error("deps not yet supported");
}
userDeps = depsExpr.elements.map(function (dep) { return getDep(dep, reflector); });
}
if (meta.has('useValue')) {
else if (isStringArrayOrDie(arg, '@' + name)) {
predicate = arg;
}
else {
throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.VALUE_HAS_WRONG_TYPE, node, "@" + name + " predicate cannot be interpreted");
}
// Extract the read and descendants options.
var read = null;
// The default value for descendants is true for every decorator except @ContentChildren.
var descendants = name !== 'ContentChildren';
if (args.length === 2) {
var optionsExpr = util_1.unwrapExpression(args[1]);
if (!ts.isObjectLiteralExpression(optionsExpr)) {
throw new Error("@" + name + " options must be an object literal");
}
var options = metadata_1.reflectObjectLiteral(optionsExpr);
if (options.has('read')) {
read = new compiler_1.WrappedNodeExpr(options.get('read'));
}
if (options.has('descendants')) {
var descendantsValue = metadata_1.staticallyResolve(options.get('descendants'), reflector, checker);
if (typeof descendantsValue !== 'boolean') {
throw new Error("@" + name + " options.descendants must be a boolean");
}
descendants = descendantsValue;
}
}
else if (args.length > 2) {
// Too many arguments.
throw new Error("@" + name + " has too many arguments");
}
return {
function extractDirectiveMetadata(clazz, decorator, checker, reflector, isCore, defaultSelector) {
if (defaultSelector === void 0) { defaultSelector = null; }
if (decorator.args === null || decorator.args.length !== 1) {
throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_ARITY_WRONG, decorator.node, "Incorrect number of arguments to @" + decorator.name + " decorator");
}
var meta = util_1.unwrapExpression(decorator.args[0]);
if (!ts.isObjectLiteralExpression(meta)) {
throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_ARG_NOT_LITERAL, meta, "@" + decorator.name + " argument must be literal.");
}
var directive = metadata_1.reflectObjectLiteral(meta);
if (directive.has('jit')) {
// The only allowed value is true, so there's no need to expand further.
return undefined;
}
var members = reflector.getMembersOfClass(clazz);
// Precompute a list of ts.ClassElements that have decorators. This includes things like @Input,
// @Output, @HostBinding, etc.
var decoratedElements = members.filter(function (member) { return !member.isStatic && member.decorators !== null; });
var coreModule = isCore ? undefined : '@angular/core';
// Construct the map of inputs both from the @Directive/@Component
// decorator, and the decorated
// fields.
var inputsFromMeta = parseFieldToPropertyMapping(directive, 'inputs', reflector, checker);
var inputsFromFields = parseDecoratedFields(metadata_1.filterToMembersWithDecorator(decoratedElements, 'Input', coreModule), reflector, checker, resolveInput);
// And outputs.
var outputsFromMeta = parseFieldToPropertyMapping(directive, 'outputs', reflector, checker);
function extractQueriesFromDecorator(queryData, reflector, checker, isCore) {
var content = [], view = [];
var expr = util_1.unwrapExpression(queryData);
if (!ts.isObjectLiteralExpression(queryData)) {
throw new Error("queries metadata must be an object literal");
}
metadata_1.reflectObjectLiteral(queryData).forEach(function (queryExpr, propertyName) {
queryExpr = util_1.unwrapExpression(queryExpr);
if (!ts.isNewExpression(queryExpr) || !ts.isIdentifier(queryExpr.expression)) {
throw new Error("query metadata must be an instance of a query type");
}
var type = reflector.getImportOfIdentifier(queryExpr.expression);
if (type === null || (!isCore && type.from !== '@angular/core') ||
!QUERY_TYPES.has(type.name)) {
throw new Error("query metadata must be an instance of a query type");
}
var query = extractQueryMetadata(queryExpr, type.name, queryExpr.arguments || [], propertyName, reflector, checker);
if (type.name.startsWith('Content')) {
content.push(query);
}
else {
view.push(query);
}
ComponentDecoratorHandler.prototype.preanalyze = function (node, decorator) {
var e_1, _a;
var meta = this._resolveLiteral(decorator);
var component = metadata_1.reflectObjectLiteral(meta);
var promises = [];
var containingFile = node.getSourceFile().fileName;
if (this.resourceLoader.preload !== undefined && component.has('templateUrl')) {
var templateUrlExpr = component.get('templateUrl');
var templateUrl = metadata_1.staticallyResolve(templateUrlExpr, this.reflector, this.checker);
if (typeof templateUrl !== 'string') {
throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.VALUE_HAS_WRONG_TYPE, templateUrlExpr, 'templateUrl must be a string');
}
var promise = this.resourceLoader.preload(templateUrl, containingFile);
if (promise !== undefined) {
promises.push(promise);
}
}
var styleUrls = this._extractStyleUrls(component);
if (this.resourceLoader.preload !== undefined && styleUrls !== null) {
try {
if (clazz.name === undefined) {
throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_ON_ANONYMOUS_CLASS, clazz, "@Pipes must have names");
}
var name = clazz.name.text;
var type = new compiler_1.WrappedNodeExpr(clazz.name);
if (decorator.args === null) {
throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_NOT_CALLED, decorator.node, "@Pipe must be called");
}
if (decorator.args.length !== 1) {
throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_ARITY_WRONG, decorator.node, '@Pipe must have exactly one argument');
}
var meta = util_1.unwrapExpression(decorator.args[0]);
if (!ts.isObjectLiteralExpression(meta)) {
throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_ARG_NOT_LITERAL, meta, '@Pipe must have a literal argument');
}
var pipe = metadata_1.reflectObjectLiteral(meta);
if (!pipe.has('name')) {
throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.PIPE_MISSING_NAME, meta, "@Pipe decorator is missing name field");
}
var pipeNameExpr = pipe.get('name');
var pipeName = metadata_1.staticallyResolve(pipeNameExpr, this.reflector, this.checker);
if (typeof pipeName !== 'string') {
throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.VALUE_HAS_WRONG_TYPE, pipeNameExpr, "@Pipe.name must be a string");
}
this.scopeRegistry.registerPipe(clazz, pipeName);
var pure = true;
if (pipe.has('pure')) {
var expr = pipe.get('pure');
var pureValue = metadata_1.staticallyResolve(expr, this.reflector, this.checker);
if (typeof pureValue !== 'boolean') {
throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.VALUE_HAS_WRONG_TYPE, expr, "@Pipe.pure must be a boolean");
}