@angular/core 15.2.6 → 15.2.8

package/fesm2020/testing.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v15.2.6
+ * @license Angular v15.2.8
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -771,30 +771,15 @@ function getOwnDefinition(type, field) {
 function getInheritedInjectableDef(type) {
     const def = type && (type[NG_PROV_DEF] || type[NG_INJECTABLE_DEF]);
     if (def) {
-        const typeName = getTypeName(type);
         ngDevMode &&
-            console.warn(`DEPRECATED: DI is instantiating a token "${typeName}" that inherits its @Injectable decorator but does not provide one itself.\n` +
-                `This will become an error in a future version of Angular. Please add @Injectable() to the "${typeName}" class.`);
+            console.warn(`DEPRECATED: DI is instantiating a token "${type.name}" that inherits its @Injectable decorator but does not provide one itself.\n` +
+                `This will become an error in a future version of Angular. Please add @Injectable() to the "${type.name}" class.`);
         return def;
     }
     else {
         return null;
     }
 }
-/** Gets the name of a type, accounting for some cross-browser differences. */
-function getTypeName(type) {
-    // `Function.prototype.name` behaves differently between IE and other browsers. In most browsers
-    // it'll always return the name of the function itself, no matter how many other functions it
-    // inherits from. On IE the function doesn't have its own `name` property, but it takes it from
-    // the lowest level in the prototype chain. E.g. if we have `class Foo extends Parent` most
-    // browsers will evaluate `Foo.name` to `Foo` while IE will return `Parent`. We work around
-    // the issue by converting the function to a string and parsing its name out that way via a regex.
-    if (type.hasOwnProperty('name')) {
-        return type.name;
-    }
-    const match = ('' + type).match(/^function\s*([^\s(]+)/);
-    return match === null ? '' : match[1];
-}
 /**
  * Read the injector def type in a way which is immune to accidentally reading inherited value.
  *
@@ -5154,8 +5139,8 @@ function validateElementIsKnown(element, lView, tagName, schemas, hasDirectives)
         // as a custom element. Note that unknown elements with a dash in their name won't be instances
         // of HTMLUnknownElement in browsers that support web components.
         const isUnknown = 
-        // Note that we can't check for `typeof HTMLUnknownElement === 'function'`,
-        // because while most browsers return 'function', IE returns 'object'.
+        // Note that we can't check for `typeof HTMLUnknownElement === 'function'` because
+        // Domino doesn't expose HTMLUnknownElement globally.
         (typeof HTMLUnknownElement !== 'undefined' && HTMLUnknownElement &&
             element instanceof HTMLUnknownElement) ||
             (typeof customElements !== 'undefined' && tagName.indexOf('-') > -1 &&
@@ -5212,8 +5197,7 @@ function isPropertyValid(element, propName, tagName, schemas) {
     if (matchingSchemas(schemas, tagName) || propName in element || isAnimationProp(propName)) {
         return true;
     }
-    // Note: `typeof Node` returns 'function' in most browsers, but on IE it is 'object' so we
-    // need to account for both here, while being careful with `typeof null` also returning 'object'.
+    // Note: `typeof Node` returns 'function' in most browsers, but is undefined with domino.
     return typeof Node === 'undefined' || Node === null || !(element instanceof Node);
 }
 /**
@@ -8705,7 +8689,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('15.2.6');
+const VERSION = new Version('15.2.8');
 
 // This default value is when checking the hierarchy for a token.
 //
@@ -12533,7 +12517,8 @@ class ComponentRef extends ComponentRef$1 {
         if (inputData !== null && (dataValue = inputData[name])) {
             const lView = this._rootLView;
             setInputsForProperty(lView[TVIEW], lView, dataValue, name, value);
-            markDirtyIfOnPush(lView, this._tNode.index);
+            const childComponentLView = getComponentLViewByIndex(this._tNode.index, lView);
+            markViewDirty(childComponentLView);
         }
         else {
             if (ngDevMode) {
@@ -15736,7 +15721,7 @@ function styleStringParser(keyValueArray, text) {
  * @codeGenApi
  */
 function ɵɵclassMap(classes) {
-    checkStylingMap(keyValueArraySet, classStringParser, classes, true);
+    checkStylingMap(classKeyValueArraySet, classStringParser, classes, true);
 }
 /**
  * Parse text as class and add values to KeyValueArray.
@@ -16178,6 +16163,26 @@ function toStylingKeyValueArray(keyValueArraySet, stringParser, value) {
 function styleKeyValueArraySet(keyValueArray, key, value) {
     keyValueArraySet(keyValueArray, key, unwrapSafeValue(value));
 }
+/**
+ * Class-binding-specific function for setting the `value` for a `key`.
+ *
+ * See: `keyValueArraySet` for details
+ *
+ * @param keyValueArray KeyValueArray to add to.
+ * @param key Style key to add.
+ * @param value The value to set.
+ */
+function classKeyValueArraySet(keyValueArray, key, value) {
+    // We use `classList.add` to eventually add the CSS classes to the DOM node. Any value passed into
+    // `add` is stringified and added to the `class` attribute, e.g. even null, undefined or numbers
+    // will be added. Stringify the key here so that our internal data structure matches the value in
+    // the DOM. The only exceptions are empty strings and strings that contain spaces for which
+    // the browser throws an error. We ignore such values, because the error is somewhat cryptic.
+    const stringKey = String(key);
+    if (stringKey !== '' && !stringKey.includes(' ')) {
+        keyValueArraySet(keyValueArray, stringKey, value);
+    }
+}
 /**
  * Update map based styling.
  *