@angular/language-service 10.0.4 → 10.0.5

package/bundles/{language-service.umd.js → language-service.js}

@@ -1,5 +1,5 @@
 /**
- * @license Angular v10.0.4
+ * @license Angular v10.0.5
  * Copyright Google LLC All Rights Reserved.
  * License: MIT
  */
@@ -2778,8 +2778,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     Identifiers$1.elementEnd = { name: 'ɵɵelementEnd', moduleName: CORE$1 };
     Identifiers$1.select = { name: 'ɵɵselect', moduleName: CORE$1 };
     Identifiers$1.advance = { name: 'ɵɵadvance', moduleName: CORE$1 };
-    Identifiers$1.updateSyntheticHostBinding = { name: 'ɵɵupdateSyntheticHostBinding', moduleName: CORE$1 };
-    Identifiers$1.componentHostSyntheticListener = { name: 'ɵɵcomponentHostSyntheticListener', moduleName: CORE$1 };
+    Identifiers$1.syntheticHostProperty = { name: 'ɵɵsyntheticHostProperty', moduleName: CORE$1 };
+    Identifiers$1.syntheticHostListener = { name: 'ɵɵsyntheticHostListener', moduleName: CORE$1 };
     Identifiers$1.attribute = { name: 'ɵɵattribute', moduleName: CORE$1 };
     Identifiers$1.attributeInterpolate1 = { name: 'ɵɵattributeInterpolate1', moduleName: CORE$1 };
     Identifiers$1.attributeInterpolate2 = { name: 'ɵɵattributeInterpolate2', moduleName: CORE$1 };
@@ -3348,6 +3348,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             this.attributes = attributes;
             this.sourceSpan = sourceSpan;
             this.i18n = i18n;
+            this.name = 'ng-content';
         }
         visit(visitor) {
             return visitor.visitContent(this);
@@ -9141,8 +9142,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             const el = new Element$1(fullName, attrs, [], span, span, undefined);
             this._pushElement(el);
             if (selfClosing) {
-                this._popElement(fullName);
-                el.endSourceSpan = span;
+                // Elements that are self-closed have their `endSourceSpan` set to the full span, as the
+                // element start tag also represents the end tag.
+                this._popElement(fullName, span);
             }
         }
         _pushElement(el) {
@@ -9155,21 +9157,22 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         }
         _consumeEndTag(endTagToken) {
             const fullName = this._getElementFullName(endTagToken.parts[0], endTagToken.parts[1], this._getParentElement());
-            if (this._getParentElement()) {
-                this._getParentElement().endSourceSpan = endTagToken.sourceSpan;
-            }
             if (this.getTagDefinition(fullName).isVoid) {
                 this.errors.push(TreeError.create(fullName, endTagToken.sourceSpan, `Void elements do not have end tags "${endTagToken.parts[1]}"`));
             }
-            else if (!this._popElement(fullName)) {
+            else if (!this._popElement(fullName, endTagToken.sourceSpan)) {
                 const errMsg = `Unexpected closing tag "${fullName}". It may happen when the tag has already been closed by another tag. For more info see https://www.w3.org/TR/html5/syntax.html#closing-elements-that-have-implied-end-tags`;
                 this.errors.push(TreeError.create(fullName, endTagToken.sourceSpan, errMsg));
             }
         }
-        _popElement(fullName) {
+        _popElement(fullName, endSourceSpan) {
             for (let stackIndex = this._elementStack.length - 1; stackIndex >= 0; stackIndex--) {
                 const el = this._elementStack[stackIndex];
                 if (el.name == fullName) {
+                    // Record the parse span with the element that is being closed. Any elements that are
+                    // removed from the element stack at this point are closed implicitly, so they won't get
+                    // an end source span (as there is no explicit closing element).
+                    el.endSourceSpan = endSourceSpan;
                     this._elementStack.splice(stackIndex, this._elementStack.length - stackIndex);
                     return true;
                 }
@@ -9202,21 +9205,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         _getParentElement() {
             return this._elementStack.length > 0 ? this._elementStack[this._elementStack.length - 1] : null;
         }
-        /**
-         * Returns the parent in the DOM and the container.
-         *
-         * `<ng-container>` elements are skipped as they are not rendered as DOM element.
-         */
-        _getParentElementSkippingContainers() {
-            let container = null;
-            for (let i = this._elementStack.length - 1; i >= 0; i--) {
-                if (!isNgContainer(this._elementStack[i].name)) {
-                    return { parent: this._elementStack[i], container };
-                }
-                container = this._elementStack[i];
-            }
-            return { parent: null, container };
-        }
         _addToParent(node) {
             const parent = this._getParentElement();
             if (parent != null) {
@@ -9226,31 +9214,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 this.rootNodes.push(node);
             }
         }
-        /**
-         * Insert a node between the parent and the container.
-         * When no container is given, the node is appended as a child of the parent.
-         * Also updates the element stack accordingly.
-         *
-         * @internal
-         */
-        _insertBeforeContainer(parent, container, node) {
-            if (!container) {
-                this._addToParent(node);
-                this._elementStack.push(node);
-            }
-            else {
-                if (parent) {
-                    // replace the container with the new node in the children
-                    const index = parent.children.indexOf(container);
-                    parent.children[index] = node;
-                }
-                else {
-                    this.rootNodes.push(node);
-                }
-                node.children.push(container);
-                this._elementStack.splice(this._elementStack.indexOf(container), 0, node);
-            }
-        }
         _getElementFullName(prefix, localName, parentElement) {
             if (prefix === '') {
                 prefix = this.getTagDefinition(localName).implicitNamespacePrefix || '';
@@ -17140,7 +17103,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             else if (instruction === Identifiers$1.attribute) {
                 attributeBindings.push(instructionParams);
             }
-            else if (instruction === Identifiers$1.updateSyntheticHostBinding) {
+            else if (instruction === Identifiers$1.syntheticHostProperty) {
                 syntheticHostBindings.push(instructionParams);
             }
             else {
@@ -17154,7 +17117,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             updateStatements.push(chainedInstruction(Identifiers$1.attribute, attributeBindings).toStmt());
         }
         if (syntheticHostBindings.length > 0) {
-            updateStatements.push(chainedInstruction(Identifiers$1.updateSyntheticHostBinding, syntheticHostBindings).toStmt());
+            updateStatements.push(chainedInstruction(Identifiers$1.syntheticHostProperty, syntheticHostBindings).toStmt());
         }
         // since we're dealing with directives/components and both have hostBinding
         // functions, we need to generate a special hostAttrs instruction that deals
@@ -17220,7 +17183,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 // host bindings that have a synthetic property (e.g. @foo) should always be rendered
                 // in the context of the component and not the parent. Therefore there is a special
                 // compatibility instruction available for this purpose.
-                instruction = Identifiers$1.updateSyntheticHostBinding;
+                instruction = Identifiers$1.syntheticHostProperty;
             }
             else {
                 instruction = Identifiers$1.hostProperty;
@@ -17247,7 +17210,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             }
         });
         if (syntheticListeners.length > 0) {
-            instructions.push(chainedInstruction(Identifiers$1.componentHostSyntheticListener, syntheticListeners).toStmt());
+            instructions.push(chainedInstruction(Identifiers$1.syntheticHostListener, syntheticListeners).toStmt());
         }
         if (listeners.length > 0) {
             instructions.push(chainedInstruction(Identifiers$1.listener, listeners).toStmt());
@@ -17623,7 +17586,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('10.0.4');
+    const VERSION$1 = new Version('10.0.5');
 
     /**
      * @license
@@ -26843,6 +26806,96 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         }
     }
 
+    /**
+     * @license
+     * Copyright Google LLC 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
+     */
+    /**
+     * Represents a basic change from a previous to a new value for a single
+     * property on a directive instance. Passed as a value in a
+     * {@link SimpleChanges} object to the `ngOnChanges` hook.
+     *
+     * @see `OnChanges`
+     *
+     * @publicApi
+     */
+    class SimpleChange {
+        constructor(previousValue, currentValue, firstChange) {
+            this.previousValue = previousValue;
+            this.currentValue = currentValue;
+            this.firstChange = firstChange;
+        }
+        /**
+         * Check whether the new value is the first value assigned.
+         */
+        isFirstChange() {
+            return this.firstChange;
+        }
+    }
+
+    /**
+     * @license
+     * Copyright Google LLC 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
+     */
+    function NgOnChangesFeatureImpl(definition) {
+        if (definition.type.prototype.ngOnChanges) {
+            definition.setInput = ngOnChangesSetInput;
+        }
+        return rememberChangeHistoryAndInvokeOnChangesHook;
+    }
+    /**
+     * This is a synthetic lifecycle hook which gets inserted into `TView.preOrderHooks` to simulate
+     * `ngOnChanges`.
+     *
+     * The hook reads the `NgSimpleChangesStore` data from the component instance and if changes are
+     * found it invokes `ngOnChanges` on the component instance.
+     *
+     * @param this Component instance. Because this function gets inserted into `TView.preOrderHooks`,
+     *     it is guaranteed to be called with component instance.
+     */
+    function rememberChangeHistoryAndInvokeOnChangesHook() {
+        const simpleChangesStore = getSimpleChangesStore(this);
+        const current = simpleChangesStore === null || simpleChangesStore === void 0 ? void 0 : simpleChangesStore.current;
+        if (current) {
+            const previous = simpleChangesStore.previous;
+            if (previous === EMPTY_OBJ) {
+                simpleChangesStore.previous = current;
+            }
+            else {
+                // New changes are copied to the previous store, so that we don't lose history for inputs
+                // which were not changed this time
+                for (let key in current) {
+                    previous[key] = current[key];
+                }
+            }
+            simpleChangesStore.current = null;
+            this.ngOnChanges(current);
+        }
+    }
+    function ngOnChangesSetInput(instance, value, publicName, privateName) {
+        const simpleChangesStore = getSimpleChangesStore(instance) ||
+            setSimpleChangesStore(instance, { previous: EMPTY_OBJ, current: null });
+        const current = simpleChangesStore.current || (simpleChangesStore.current = {});
+        const previous = simpleChangesStore.previous;
+        const declaredName = this.declaredInputs[publicName];
+        const previousChange = previous[declaredName];
+        current[declaredName] = new SimpleChange(previousChange && previousChange.currentValue, value, previous === EMPTY_OBJ);
+        instance[privateName] = value;
+    }
+    const SIMPLE_CHANGES_STORE = '__ngSimpleChanges__';
+    function getSimpleChangesStore(instance) {
+        return instance[SIMPLE_CHANGES_STORE] || null;
+    }
+    function setSimpleChangesStore(instance, store) {
+        return instance[SIMPLE_CHANGES_STORE] = store;
+    }
+
     /**
      * @license
      * Copyright Google LLC All Rights Reserved.
@@ -27256,17 +27309,19 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      */
     function registerPreOrderHooks(directiveIndex, directiveDef, tView) {
         ngDevMode && assertFirstCreatePass(tView);
-        const { onChanges, onInit, doCheck } = directiveDef;
-        if (onChanges) {
-            (tView.preOrderHooks || (tView.preOrderHooks = [])).push(directiveIndex, onChanges);
-            (tView.preOrderCheckHooks || (tView.preOrderCheckHooks = [])).push(directiveIndex, onChanges);
+        const { ngOnChanges, ngOnInit, ngDoCheck } = directiveDef.type.prototype;
+        if (ngOnChanges) {
+            const wrappedOnChanges = NgOnChangesFeatureImpl(directiveDef);
+            (tView.preOrderHooks || (tView.preOrderHooks = [])).push(directiveIndex, wrappedOnChanges);
+            (tView.preOrderCheckHooks || (tView.preOrderCheckHooks = []))
+                .push(directiveIndex, wrappedOnChanges);
         }
-        if (onInit) {
-            (tView.preOrderHooks || (tView.preOrderHooks = [])).push(-directiveIndex, onInit);
+        if (ngOnInit) {
+            (tView.preOrderHooks || (tView.preOrderHooks = [])).push(0 - directiveIndex, ngOnInit);
         }
-        if (doCheck) {
-            (tView.preOrderHooks || (tView.preOrderHooks = [])).push(directiveIndex, doCheck);
-            (tView.preOrderCheckHooks || (tView.preOrderCheckHooks = [])).push(directiveIndex, doCheck);
+        if (ngDoCheck) {
+            (tView.preOrderHooks || (tView.preOrderHooks = [])).push(directiveIndex, ngDoCheck);
+            (tView.preOrderCheckHooks || (tView.preOrderCheckHooks = [])).push(directiveIndex, ngDoCheck);
         }
     }
     /**
@@ -27294,23 +27349,24 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         // hooks for projected components and directives must be called *before* their hosts.
         for (let i = tNode.directiveStart, end = tNode.directiveEnd; i < end; i++) {
             const directiveDef = tView.data[i];
-            if (directiveDef.afterContentInit) {
-                (tView.contentHooks || (tView.contentHooks = [])).push(-i, directiveDef.afterContentInit);
+            const lifecycleHooks = directiveDef.type.prototype;
+            const { ngAfterContentInit, ngAfterContentChecked, ngAfterViewInit, ngAfterViewChecked, ngOnDestroy } = lifecycleHooks;
+            if (ngAfterContentInit) {
+                (tView.contentHooks || (tView.contentHooks = [])).push(-i, ngAfterContentInit);
             }
-            if (directiveDef.afterContentChecked) {
-                (tView.contentHooks || (tView.contentHooks = [])).push(i, directiveDef.afterContentChecked);
-                (tView.contentCheckHooks || (tView.contentCheckHooks = []))
-                    .push(i, directiveDef.afterContentChecked);
+            if (ngAfterContentChecked) {
+                (tView.contentHooks || (tView.contentHooks = [])).push(i, ngAfterContentChecked);
+                (tView.contentCheckHooks || (tView.contentCheckHooks = [])).push(i, ngAfterContentChecked);
             }
-            if (directiveDef.afterViewInit) {
-                (tView.viewHooks || (tView.viewHooks = [])).push(-i, directiveDef.afterViewInit);
+            if (ngAfterViewInit) {
+                (tView.viewHooks || (tView.viewHooks = [])).push(-i, ngAfterViewInit);
             }
-            if (directiveDef.afterViewChecked) {
-                (tView.viewHooks || (tView.viewHooks = [])).push(i, directiveDef.afterViewChecked);
-                (tView.viewCheckHooks || (tView.viewCheckHooks = [])).push(i, directiveDef.afterViewChecked);
+            if (ngAfterViewChecked) {
+                (tView.viewHooks || (tView.viewHooks = [])).push(i, ngAfterViewChecked);
+                (tView.viewCheckHooks || (tView.viewCheckHooks = [])).push(i, ngAfterViewChecked);
             }
-            if (directiveDef.onDestroy != null) {
-                (tView.destroyHooks || (tView.destroyHooks = [])).push(i, directiveDef.onDestroy);
+            if (ngOnDestroy != null) {
+                (tView.destroyHooks || (tView.destroyHooks = [])).push(i, ngOnDestroy);
             }
         }
     }
@@ -28134,10 +28190,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     function locateDirectiveOrProvider(tNode, tView, token, canAccessViewProviders, isHostSpecialCase) {
         const nodeProviderIndexes = tNode.providerIndexes;
         const tInjectables = tView.data;
-        const injectablesStart = nodeProviderIndexes & 65535 /* ProvidersStartIndexMask */;
+        const injectablesStart = nodeProviderIndexes & 1048575 /* ProvidersStartIndexMask */;
         const directivesStart = tNode.directiveStart;
         const directiveEnd = tNode.directiveEnd;
-        const cptViewProvidersCount = nodeProviderIndexes >> 16 /* CptViewProvidersCountShift */;
+        const cptViewProvidersCount = nodeProviderIndexes >> 20 /* CptViewProvidersCountShift */;
         const startingIndex = canAccessViewProviders ? injectablesStart : injectablesStart + cptViewProvidersCount;
         // When the host special case applies, only the viewProviders and the component are visible
         const endIndex = isHostSpecialCase ? injectablesStart + cptViewProvidersCount : directiveEnd;
@@ -29364,6 +29420,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                     else {
                         // If it's not a number, it's a host binding function that needs to be executed.
                         if (instruction !== null) {
+                            ngDevMode &&
+                                assertLessThan(currentDirectiveIndex, 1048576 /* CptViewProvidersCountShifter */, 'Reached the max number of host bindings');
                             setBindingRootForHostBindings(bindingRootIndex, currentDirectiveIndex);
                             const hostCtx = lView[currentDirectiveIndex];
                             instruction(2 /* Update */, hostCtx);
@@ -30041,7 +30099,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         // requires non standard math arithmetic and it can prevent VM optimizations.
         // `0-0` will always produce `0` and will not cause a potential deoptimization in VM.
         const elementIndex = HEADER_OFFSET - tNode.index;
-        const providerStartIndex = tNode.providerIndexes & 65535 /* ProvidersStartIndexMask */;
+        const providerStartIndex = tNode.providerIndexes & 1048575 /* ProvidersStartIndexMask */;
         const providerCount = tView.data.length - providerStartIndex;
         (tView.expandoInstructions || (tView.expandoInstructions = []))
             .push(elementIndex, providerCount, directiveCount);
@@ -33401,7 +33459,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     /**
      * @publicApi
      */
-    const VERSION$2 = new Version$1('10.0.4');
+    const VERSION$2 = new Version$1('10.0.5');
 
     /**
      * @license
@@ -40852,4 +40910,4 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     Object.defineProperty(exports, '__esModule', { value: true });
 
 });
-//# sourceMappingURL=language-service.umd.js.map
+//# sourceMappingURL=language-service.js.map

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@angular/language-service",
-  "version": "10.0.4",
+  "version": "10.0.5",
   "description": "Angular - language services",
-  "main": "./bundles/language-service.umd.js",
+  "main": "./bundles/language-service.js",
   "typings": "./index.d.ts",
   "author": "angular",
   "license": "MIT",