@angular/language-service 12.1.0-next.4 → 12.1.1

package/bundles/language-service.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v12.1.0-next.4
+ * @license Angular v12.1.1
  * Copyright Google LLC All Rights Reserved.
  * License: MIT
  */
@@ -4700,8 +4700,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             // There is a base factory variable so wrap its declaration along with the factory function into
             // an IIFE.
             factoryFn = fn([], [
-                new DeclareVarStmt(baseFactoryVar.name),
-                new ReturnStatement(factoryFn)
+                new DeclareVarStmt(baseFactoryVar.name), new ReturnStatement(factoryFn)
             ]).callFn([], /* sourceSpan */ undefined, /* pure */ true);
         }
         return {
@@ -6492,19 +6491,29 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         }
     }
     class KeyedRead extends AST {
-        constructor(span, sourceSpan, obj, key) {
+        constructor(span, sourceSpan, receiver, key) {
             super(span, sourceSpan);
-            this.obj = obj;
+            this.receiver = receiver;
             this.key = key;
         }
         visit(visitor, context = null) {
             return visitor.visitKeyedRead(this, context);
         }
     }
+    class SafeKeyedRead extends AST {
+        constructor(span, sourceSpan, receiver, key) {
+            super(span, sourceSpan);
+            this.receiver = receiver;
+            this.key = key;
+        }
+        visit(visitor, context = null) {
+            return visitor.visitSafeKeyedRead(this, context);
+        }
+    }
     class KeyedWrite extends AST {
-        constructor(span, sourceSpan, obj, key, value) {
+        constructor(span, sourceSpan, receiver, key, value) {
             super(span, sourceSpan);
-            this.obj = obj;
+            this.receiver = receiver;
             this.key = key;
             this.value = value;
         }
@@ -6753,11 +6762,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             this.visitAll(ast.expressions, context);
         }
         visitKeyedRead(ast, context) {
-            this.visit(ast.obj, context);
+            this.visit(ast.receiver, context);
             this.visit(ast.key, context);
         }
         visitKeyedWrite(ast, context) {
-            this.visit(ast.obj, context);
+            this.visit(ast.receiver, context);
             this.visit(ast.key, context);
             this.visit(ast.value, context);
         }
@@ -6792,6 +6801,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             this.visit(ast.receiver, context);
             this.visitAll(ast.args, context);
         }
+        visitSafeKeyedRead(ast, context) {
+            this.visit(ast.receiver, context);
+            this.visit(ast.key, context);
+        }
         visitQuote(ast, context) { }
         // This is not part of the AstVisitor interface, just a helper method
         visitAll(asts, context) {
@@ -6863,10 +6876,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             return new BindingPipe(ast.span, ast.sourceSpan, ast.exp.visit(this), ast.name, this.visitAll(ast.args), ast.nameSpan);
         }
         visitKeyedRead(ast, context) {
-            return new KeyedRead(ast.span, ast.sourceSpan, ast.obj.visit(this), ast.key.visit(this));
+            return new KeyedRead(ast.span, ast.sourceSpan, ast.receiver.visit(this), ast.key.visit(this));
         }
         visitKeyedWrite(ast, context) {
-            return new KeyedWrite(ast.span, ast.sourceSpan, ast.obj.visit(this), ast.key.visit(this), ast.value.visit(this));
+            return new KeyedWrite(ast.span, ast.sourceSpan, ast.receiver.visit(this), ast.key.visit(this), ast.value.visit(this));
         }
         visitAll(asts) {
             const res = [];
@@ -6881,6 +6894,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         visitQuote(ast, context) {
             return new Quote(ast.span, ast.sourceSpan, ast.prefix, ast.uninterpretedExpression, ast.location);
         }
+        visitSafeKeyedRead(ast, context) {
+            return new SafeKeyedRead(ast.span, ast.sourceSpan, ast.receiver.visit(this), ast.key.visit(this));
+        }
     }
     // A transformer that only creates new nodes if the transformer makes a change or
     // a change is made a child node.
@@ -7014,18 +7030,18 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             return ast;
         }
         visitKeyedRead(ast, context) {
-            const obj = ast.obj.visit(this);
+            const obj = ast.receiver.visit(this);
             const key = ast.key.visit(this);
-            if (obj !== ast.obj || key !== ast.key) {
+            if (obj !== ast.receiver || key !== ast.key) {
                 return new KeyedRead(ast.span, ast.sourceSpan, obj, key);
             }
             return ast;
         }
         visitKeyedWrite(ast, context) {
-            const obj = ast.obj.visit(this);
+            const obj = ast.receiver.visit(this);
             const key = ast.key.visit(this);
             const value = ast.value.visit(this);
-            if (obj !== ast.obj || key !== ast.key || value !== ast.value) {
+            if (obj !== ast.receiver || key !== ast.key || value !== ast.value) {
                 return new KeyedWrite(ast.span, ast.sourceSpan, obj, key, value);
             }
             return ast;
@@ -7051,6 +7067,14 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         visitQuote(ast, context) {
             return ast;
         }
+        visitSafeKeyedRead(ast, context) {
+            const obj = ast.receiver.visit(this);
+            const key = ast.key.visit(this);
+            if (obj !== ast.receiver || key !== ast.key) {
+                return new SafeKeyedRead(ast.span, ast.sourceSpan, obj, key);
+            }
+            return ast;
+        }
     }
     // Bindings
     class ParsedProperty {
@@ -7615,13 +7639,16 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 return this.convertSafeAccess(ast, leftMostSafe, mode);
             }
             else {
-                return convertToStatementIfNeeded(mode, this._visit(ast.obj, _Mode.Expression).key(this._visit(ast.key, _Mode.Expression)));
+                return convertToStatementIfNeeded(mode, this._visit(ast.receiver, _Mode.Expression).key(this._visit(ast.key, _Mode.Expression)));
             }
         }
         visitKeyedWrite(ast, mode) {
-            const obj = this._visit(ast.obj, _Mode.Expression);
+            const obj = this._visit(ast.receiver, _Mode.Expression);
             const key = this._visit(ast.key, _Mode.Expression);
             const value = this._visit(ast.value, _Mode.Expression);
+            if (obj === this._implicitReceiver) {
+                this._localResolver.maybeRestoreView(0, false);
+            }
             return convertToStatementIfNeeded(mode, obj.key(key).set(value));
         }
         visitLiteralArray(ast, mode) {
@@ -7747,6 +7774,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         visitSafeMethodCall(ast, mode) {
             return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode);
         }
+        visitSafeKeyedRead(ast, mode) {
+            return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode);
+        }
         visitAll(asts, mode) {
             return asts.map(ast => this._visit(ast, mode));
         }
@@ -7813,6 +7843,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             if (leftMostSafe instanceof SafeMethodCall) {
                 this._nodeMap.set(leftMostSafe, new MethodCall(leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.nameSpan, leftMostSafe.receiver, leftMostSafe.name, leftMostSafe.args, leftMostSafe.argumentSpan));
             }
+            else if (leftMostSafe instanceof SafeKeyedRead) {
+                this._nodeMap.set(leftMostSafe, new KeyedRead(leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.receiver, leftMostSafe.key));
+            }
             else {
                 this._nodeMap.set(leftMostSafe, new PropertyRead(leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.nameSpan, leftMostSafe.receiver, leftMostSafe.name));
             }
@@ -7879,7 +7912,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                     return null;
                 },
                 visitKeyedRead(ast) {
-                    return visit(this, ast.obj);
+                    return visit(this, ast.receiver);
                 },
                 visitKeyedWrite(ast) {
                     return null;
@@ -7919,6 +7952,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 },
                 visitSafePropertyRead(ast) {
                     return visit(this, ast.receiver) || ast;
+                },
+                visitSafeKeyedRead(ast) {
+                    return visit(this, ast.receiver) || ast;
                 }
             });
         }
@@ -7998,6 +8034,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 },
                 visitSafePropertyRead(ast) {
                     return false;
+                },
+                visitSafeKeyedRead(ast) {
+                    return false;
                 }
             });
         }
@@ -8054,6 +8093,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             this.globals = globals;
         }
         notifyImplicitReceiverUse() { }
+        maybeRestoreView() { }
         getLocal(name) {
             if (name === EventHandlerVars.event.name) {
                 return EventHandlerVars.event;
@@ -9599,10 +9639,13 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                     parts.push(this._readChar(true));
                 }
             } while (!this._isTextEnd());
+            // It is possible that an interpolation was started but not ended inside this text token.
+            // Make sure that we reset the state of the lexer correctly.
+            this._inInterpolation = false;
             this._endToken([this._processCarriageReturns(parts.join(''))]);
         }
         _isTextEnd() {
-            if (this._cursor.peek() === $LT || this._cursor.peek() === $EOF) {
+            if (this._isTagStart() || this._cursor.peek() === $EOF) {
                 return true;
             }
             if (this._tokenizeIcu && !this._inInterpolation) {
@@ -9617,6 +9660,24 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             }
             return false;
         }
+        /**
+         * Returns true if the current cursor is pointing to the start of a tag
+         * (opening/closing/comments/cdata/etc).
+         */
+        _isTagStart() {
+            if (this._cursor.peek() === $LT) {
+                // We assume that `<` followed by whitespace is not the start of an HTML element.
+                const tmp = this._cursor.clone();
+                tmp.advance();
+                // If the next character is alphabetic, ! nor / then it is a tag start
+                const code = tmp.peek();
+                if (($a <= code && code <= $z) || ($A <= code && code <= $Z) ||
+                    code === $SLASH || code === $BANG) {
+                    return true;
+                }
+            }
+            return false;
+        }
         _readUntil(char) {
             const start = this._cursor.clone();
             this._attemptUntilChar(char);
@@ -10189,6 +10250,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
          * opening tag is recovered).
          */
         _popElement(fullName, endSourceSpan) {
+            let unexpectedCloseTagDetected = false;
             for (let stackIndex = this._elementStack.length - 1; stackIndex >= 0; stackIndex--) {
                 const el = this._elementStack[stackIndex];
                 if (el.name == fullName) {
@@ -10198,10 +10260,13 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                     el.endSourceSpan = endSourceSpan;
                     el.sourceSpan.end = endSourceSpan !== null ? endSourceSpan.end : el.sourceSpan.end;
                     this._elementStack.splice(stackIndex, this._elementStack.length - stackIndex);
-                    return true;
+                    return !unexpectedCloseTagDetected;
                 }
                 if (!this.getTagDefinition(el.name).closedByParent) {
-                    return false;
+                    // Note that we encountered an unexpected close tag but continue processing the element
+                    // stack so we can assign an `endSourceSpan` if there is a corresponding start tag for this
+                    // end tag in the stack.
+                    unexpectedCloseTagDetected = true;
                 }
             }
             return false;
@@ -14199,25 +14264,12 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                     result = this.parseAccessMemberOrMethodCall(result, start, false);
                 }
                 else if (this.consumeOptionalOperator('?.')) {
-                    result = this.parseAccessMemberOrMethodCall(result, start, true);
+                    result = this.consumeOptionalCharacter($LBRACKET) ?
+                        this.parseKeyedReadOrWrite(result, start, true) :
+                        this.parseAccessMemberOrMethodCall(result, start, true);
                 }
                 else if (this.consumeOptionalCharacter($LBRACKET)) {
-                    this.withContext(ParseContextFlags.Writable, () => {
-                        this.rbracketsExpected++;
-                        const key = this.parsePipe();
-                        if (key instanceof EmptyExpr) {
-                            this.error(`Key access cannot be empty`);
-                        }
-                        this.rbracketsExpected--;
-                        this.expectCharacter($RBRACKET);
-                        if (this.consumeOptionalOperator('=')) {
-                            const value = this.parseConditional();
-                            result = new KeyedWrite(this.span(start), this.sourceSpan(start), result, key, value);
-                        }
-                        else {
-                            result = new KeyedRead(this.span(start), this.sourceSpan(start), result, key);
-                        }
-                    });
+                    result = this.parseKeyedReadOrWrite(result, start, false);
                 }
                 else if (this.consumeOptionalCharacter($LPAREN)) {
                     this.rparensExpected++;
@@ -14319,18 +14371,30 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             if (!this.consumeOptionalCharacter($RBRACE)) {
                 this.rbracesExpected++;
                 do {
+                    const keyStart = this.inputIndex;
                     const quoted = this.next.isString();
                     const key = this.expectIdentifierOrKeywordOrString();
                     keys.push({ key, quoted });
-                    this.expectCharacter($COLON);
-                    values.push(this.parsePipe());
+                    // Properties with quoted keys can't use the shorthand syntax.
+                    if (quoted) {
+                        this.expectCharacter($COLON);
+                        values.push(this.parsePipe());
+                    }
+                    else if (this.consumeOptionalCharacter($COLON)) {
+                        values.push(this.parsePipe());
+                    }
+                    else {
+                        const span = this.span(keyStart);
+                        const sourceSpan = this.sourceSpan(keyStart);
+                        values.push(new PropertyRead(span, sourceSpan, sourceSpan, new ImplicitReceiver(span, sourceSpan), key));
+                    }
                 } while (this.consumeOptionalCharacter($COMMA));
                 this.rbracesExpected--;
                 this.expectCharacter($RBRACE);
             }
             return new LiteralMap(this.span(start), this.sourceSpan(start), keys, values);
         }
-        parseAccessMemberOrMethodCall(receiver, start, isSafe = false) {
+        parseAccessMemberOrMethodCall(receiver, start, isSafe) {
             const nameStart = this.inputIndex;
             const id = this.withContext(ParseContextFlags.Writable, () => {
                 var _a;
@@ -14465,6 +14529,31 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             }
             return new TemplateBindingParseResult(bindings, [] /* warnings */, this.errors);
         }
+        parseKeyedReadOrWrite(receiver, start, isSafe) {
+            return this.withContext(ParseContextFlags.Writable, () => {
+                this.rbracketsExpected++;
+                const key = this.parsePipe();
+                if (key instanceof EmptyExpr) {
+                    this.error(`Key access cannot be empty`);
+                }
+                this.rbracketsExpected--;
+                this.expectCharacter($RBRACKET);
+                if (this.consumeOptionalOperator('=')) {
+                    if (isSafe) {
+                        this.error('The \'?.\' operator cannot be used in the assignment');
+                    }
+                    else {
+                        const value = this.parseConditional();
+                        return new KeyedWrite(this.span(start), this.sourceSpan(start), receiver, key, value);
+                    }
+                }
+                else {
+                    return isSafe ? new SafeKeyedRead(this.span(start), this.sourceSpan(start), receiver, key) :
+                        new KeyedRead(this.span(start), this.sourceSpan(start), receiver, key);
+                }
+                return new EmptyExpr(this.span(start), this.sourceSpan(start));
+            });
+        }
         /**
          * Parse a directive keyword, followed by a mandatory expression.
          * For example, "of items", "trackBy: func".
@@ -14672,6 +14761,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         }
         visitChain(ast, context) { }
         visitQuote(ast, context) { }
+        visitSafeKeyedRead(ast, context) { }
     }
     /**
      * This class implements SimpleExpressionChecker used in View Engine and performs more strict checks
@@ -16860,6 +16950,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         notifyImplicitReceiverUse() {
             this._bindingScope.notifyImplicitReceiverUse();
         }
+        // LocalResolver
+        maybeRestoreView(retrievalLevel, localRefLookup) {
+            this._bindingScope.maybeRestoreView(retrievalLevel, localRefLookup);
+        }
         i18nTranslate(message, params = {}, ref, transformFn) {
             const _ref = ref || this.i18nGenerateMainBlockVar();
             // Closure Compiler requires const names to start with `MSG_` but disallows any other const to
@@ -19500,7 +19594,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      * 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
      */
-    const VERSION$1 = new Version('12.1.0-next.4');
+    const VERSION$1 = new Version('12.1.1');
 
     /**
      * @license
@@ -23665,7 +23759,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             return this.undefinedType;
         }
         visitKeyedRead(ast) {
-            const targetType = this.getType(ast.obj);
+            const targetType = this.getType(ast.receiver);
             const keyType = this.getType(ast.key);
             const result = targetType.indexed(keyType, ast.key instanceof LiteralPrimitive ? ast.key.value : undefined);
             return result || this.anyType;
@@ -23754,6 +23848,12 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         visitSafePropertyRead(ast) {
             return this.resolvePropertyRead(this.query.getNonNullableType(this.getType(ast.receiver)), ast);
         }
+        visitSafeKeyedRead(ast) {
+            const targetType = this.query.getNonNullableType(this.getType(ast.receiver));
+            const keyType = this.getType(ast.key);
+            const result = targetType.indexed(keyType, ast.key instanceof LiteralPrimitive ? ast.key.value : undefined);
+            return result || this.anyType;
+        }
         /**
          * Gets the source of an expession AST.
          * The AST's sourceSpan is relative to the start of the template source code, which is contained
@@ -24248,6 +24348,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 result = undefined;
             },
             visitKeyedRead(_ast) { },
+            visitSafeKeyedRead(_ast) { },
             visitKeyedWrite(_ast) { },
             visitLiteralArray(_ast) { },
             visitLiteralMap(_ast) { },
@@ -24335,6 +24436,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             visitThisReceiver(_ast) { },
             visitInterpolation(_ast) { },
             visitKeyedRead(_ast) { },
+            visitSafeKeyedRead(_ast) { },
             visitKeyedWrite(_ast) { },
             visitLiteralArray(_ast) { },
             visitLiteralMap(_ast) { },
@@ -25048,6 +25150,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         function allParameterTypesMatch(signature) {
             const tc = context.checker;
             return signature.getParameters().every((parameter, i) => {
+                if (parameter.valueDeclaration === undefined) {
+                    return false;
+                }
                 const type = tc.getTypeOfSymbolAtLocation(parameter, parameter.valueDeclaration);
                 return type === passedInTypes[i];
             });
@@ -35407,6 +35512,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      * then use the factory's `create()` method to create a component of that type.
      *
      * @see [Dynamic Components](guide/dynamic-component-loader)
+     * @see [Usage Example](guide/dynamic-component-loader#resolving-components)
+     * @see <live-example name="dynamic-component-loader" noDownload></live-example>
+    of the code in this cookbook
      * @publicApi
      */
     class ComponentFactoryResolver {
@@ -35568,7 +35676,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     /**
      * @publicApi
      */
-    const VERSION$2 = new Version$1('12.1.0-next.4');
+    const VERSION$2 = new Version$1('12.1.1');
 
     /**
      * @license
@@ -40676,20 +40784,41 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 merge$1(isCurrentlyStable, isStable.pipe(share()));
         }
         /**
-         * Bootstrap a new component at the root level of the application.
+         * Bootstrap a component onto the element identified by its selector or, optionally, to a
+         * specified element.
          *
          * @usageNotes
          * ### Bootstrap process
          *
-         * When bootstrapping a new root component into an application, Angular mounts the
-         * specified application component onto DOM elements identified by the componentType's
-         * selector and kicks off automatic change detection to finish initializing the component.
+         * When bootstrapping a component, Angular mounts it onto a target DOM element
+         * and kicks off automatic change detection. The target DOM element can be
+         * provided using the `rootSelectorOrNode` argument.
          *
-         * Optionally, a component can be mounted onto a DOM element that does not match the
-         * componentType's selector.
+         * If the target DOM element is not provided, Angular tries to find one on a page
+         * using the `selector` of the component that is being bootstrapped
+         * (first matched element is used).
          *
          * ### Example
-         * {@example core/ts/platform/platform.ts region='longform'}
+         *
+         * Generally, we define the component to bootstrap in the `bootstrap` array of `NgModule`,
+         * but it requires us to know the component while writing the application code.
+         *
+         * Imagine a situation where we have to wait for an API call to decide about the component to
+         * bootstrap. We can use the `ngDoBootstrap` hook of the `NgModule` and call this method to
+         * dynamically bootstrap a component.
+         *
+         * {@example core/ts/platform/platform.ts region='componentSelector'}
+         *
+         * Optionally, a component can be mounted onto a DOM element that does not match the
+         * selector of the bootstrapped component.
+         *
+         * In the following example, we are providing a CSS selector to match the target element.
+         *
+         * {@example core/ts/platform/platform.ts region='cssSelector'}
+         *
+         * While in this example, we are providing reference to a DOM node.
+         *
+         * {@example core/ts/platform/platform.ts region='domNode'}
          */
         bootstrap(componentOrFactory, rootSelectorOrNode) {
             if (!this._initStatus.done) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/language-service",
-  "version": "12.1.0-next.4",
+  "version": "12.1.1",
   "description": "Angular - language services",
   "main": "./index.js",
   "typings": "./index.d.ts",