@angular/compiler 14.2.0 → 15.0.0-next.1

package/fesm2015/testing.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v14.2.0
+ * @license Angular v15.0.0-next.1
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */

package/fesm2020/compiler.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v14.2.0
+ * @license Angular v15.0.0-next.1
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -2922,6 +2922,7 @@ Identifiers.InheritDefinitionFeature = { name: 'ɵɵInheritDefinitionFeature', m
 Identifiers.CopyDefinitionFeature = { name: 'ɵɵCopyDefinitionFeature', moduleName: CORE };
 Identifiers.StandaloneFeature = { name: 'ɵɵStandaloneFeature', moduleName: CORE };
 Identifiers.ProvidersFeature = { name: 'ɵɵProvidersFeature', moduleName: CORE };
+Identifiers.HostDirectivesFeature = { name: 'ɵɵHostDirectivesFeature', moduleName: CORE };
 Identifiers.listener = { name: 'ɵɵlistener', moduleName: CORE };
 Identifiers.getInheritedFactory = {
     name: 'ɵɵgetInheritedFactory',
@@ -14784,42 +14785,42 @@ const SCHEMA = [
     'time^[HTMLElement]|dateTime',
     ':svg:cursor^:svg:|',
 ];
-const _ATTR_TO_PROP = {
+const _ATTR_TO_PROP = new Map(Object.entries({
     'class': 'className',
     'for': 'htmlFor',
     'formaction': 'formAction',
     'innerHtml': 'innerHTML',
     'readonly': 'readOnly',
     'tabindex': 'tabIndex',
-};
+}));
 // Invert _ATTR_TO_PROP.
-const _PROP_TO_ATTR = Object.keys(_ATTR_TO_PROP).reduce((inverted, attr) => {
-    inverted[_ATTR_TO_PROP[attr]] = attr;
+const _PROP_TO_ATTR = Array.from(_ATTR_TO_PROP).reduce((inverted, [propertyName, attributeName]) => {
+    inverted.set(propertyName, attributeName);
     return inverted;
-}, {});
+}, new Map());
 class DomElementSchemaRegistry extends ElementSchemaRegistry {
     constructor() {
         super();
-        this._schema = {};
+        this._schema = new Map();
         // We don't allow binding to events for security reasons. Allowing event bindings would almost
         // certainly introduce bad XSS vulnerabilities. Instead, we store events in a separate schema.
-        this._eventSchema = {};
+        this._eventSchema = new Map;
         SCHEMA.forEach(encodedType => {
-            const type = {};
+            const type = new Map();
             const events = new Set();
             const [strType, strProperties] = encodedType.split('|');
             const properties = strProperties.split(',');
             const [typeNames, superName] = strType.split('^');
             typeNames.split(',').forEach(tag => {
-                this._schema[tag.toLowerCase()] = type;
-                this._eventSchema[tag.toLowerCase()] = events;
+                this._schema.set(tag.toLowerCase(), type);
+                this._eventSchema.set(tag.toLowerCase(), events);
             });
-            const superType = superName && this._schema[superName.toLowerCase()];
+            const superType = superName && this._schema.get(superName.toLowerCase());
             if (superType) {
-                Object.keys(superType).forEach((prop) => {
-                    type[prop] = superType[prop];
-                });
-                for (const superEvent of this._eventSchema[superName.toLowerCase()]) {
+                for (const [prop, value] of superType) {
+                    type.set(prop, value);
+                }
+                for (const superEvent of this._eventSchema.get(superName.toLowerCase())) {
                     events.add(superEvent);
                 }
             }
@@ -14830,16 +14831,16 @@ class DomElementSchemaRegistry extends ElementSchemaRegistry {
                             events.add(property.substring(1));
                             break;
                         case '!':
-                            type[property.substring(1)] = BOOLEAN;
+                            type.set(property.substring(1), BOOLEAN);
                             break;
                         case '#':
-                            type[property.substring(1)] = NUMBER;
+                            type.set(property.substring(1), NUMBER);
                             break;
                         case '%':
-                            type[property.substring(1)] = OBJECT;
+                            type.set(property.substring(1), OBJECT);
                             break;
                         default:
-                            type[property] = STRING;
+                            type.set(property, STRING);
                     }
                 }
             });
@@ -14859,8 +14860,8 @@ class DomElementSchemaRegistry extends ElementSchemaRegistry {
                 return true;
             }
         }
-        const elementProperties = this._schema[tagName.toLowerCase()] || this._schema['unknown'];
-        return !!elementProperties[propName];
+        const elementProperties = this._schema.get(tagName.toLowerCase()) || this._schema.get('unknown');
+        return elementProperties.has(propName);
     }
     hasElement(tagName, schemaMetas) {
         if (schemaMetas.some((schema) => schema.name === NO_ERRORS_SCHEMA.name)) {
@@ -14875,7 +14876,7 @@ class DomElementSchemaRegistry extends ElementSchemaRegistry {
                 return true;
             }
         }
-        return !!this._schema[tagName.toLowerCase()];
+        return this._schema.has(tagName.toLowerCase());
     }
     /**
      * securityContext returns the security context for the given property on the given DOM tag.
@@ -14904,7 +14905,7 @@ class DomElementSchemaRegistry extends ElementSchemaRegistry {
         return ctx ? ctx : SecurityContext.NONE;
     }
     getMappedPropName(propName) {
-        return _ATTR_TO_PROP[propName] || propName;
+        return _ATTR_TO_PROP.get(propName) ?? propName;
     }
     getDefaultComponentElementName() {
         return 'ng-component';
@@ -14932,15 +14933,15 @@ class DomElementSchemaRegistry extends ElementSchemaRegistry {
         }
     }
     allKnownElementNames() {
-        return Object.keys(this._schema);
+        return Array.from(this._schema.keys());
     }
     allKnownAttributesOfElement(tagName) {
-        const elementProperties = this._schema[tagName.toLowerCase()] || this._schema['unknown'];
+        const elementProperties = this._schema.get(tagName.toLowerCase()) || this._schema.get('unknown');
         // Convert properties to attributes.
-        return Object.keys(elementProperties).map(prop => _PROP_TO_ATTR[prop] ?? prop);
+        return Array.from(elementProperties.keys()).map(prop => _PROP_TO_ATTR.get(prop) ?? prop);
     }
     allKnownEventsOfElement(tagName) {
-        return Array.from(this._eventSchema[tagName.toLowerCase()] ?? []);
+        return Array.from(this._eventSchema.get(tagName.toLowerCase()) ?? []);
     }
     normalizeAnimationStyleProperty(propName) {
         return dashCaseToCamelCase(propName);
@@ -18829,6 +18830,9 @@ function addFeatures(definitionMap, meta) {
     if (meta.hasOwnProperty('template') && meta.isStandalone) {
         features.push(importExpr(Identifiers.StandaloneFeature));
     }
+    if (meta.hostDirectives?.length) {
+        features.push(importExpr(Identifiers.HostDirectivesFeature).callFn([createHostDirectivesFeatureArg(meta.hostDirectives)]));
+    }
     if (features.length) {
         definitionMap.set('features', literalArr(features));
     }
@@ -18941,6 +18945,7 @@ function createComponentType(meta) {
     const typeParams = createBaseDirectiveTypeParams(meta);
     typeParams.push(stringArrayAsType(meta.template.ngContentSelectors));
     typeParams.push(expressionType(literal(meta.isStandalone)));
+    typeParams.push(createHostDirectivesType(meta));
     return expressionType(importExpr(Identifiers.ComponentDeclaration, typeParams));
 }
 /**
@@ -19016,7 +19021,7 @@ function createContentQueriesFunction(queries, constantPool, name) {
 function stringAsType(str) {
     return expressionType(literal(str));
 }
-function stringMapAsType(map) {
+function stringMapAsLiteralExpression(map) {
     const mapValues = Object.keys(map).map(key => {
         const value = Array.isArray(map[key]) ? map[key][0] : map[key];
         return {
@@ -19025,7 +19030,7 @@ function stringMapAsType(map) {
             quoted: true,
         };
     });
-    return expressionType(literalMap(mapValues));
+    return literalMap(mapValues);
 }
 function stringArrayAsType(arr) {
     return arr.length > 0 ? expressionType(literalArr(arr.map(value => literal(value)))) :
@@ -19039,8 +19044,8 @@ function createBaseDirectiveTypeParams(meta) {
         typeWithParameters(meta.type.type, meta.typeArgumentCount),
         selectorForType !== null ? stringAsType(selectorForType) : NONE_TYPE,
         meta.exportAs !== null ? stringArrayAsType(meta.exportAs) : NONE_TYPE,
-        stringMapAsType(meta.inputs),
-        stringMapAsType(meta.outputs),
+        expressionType(stringMapAsLiteralExpression(meta.inputs)),
+        expressionType(stringMapAsLiteralExpression(meta.outputs)),
         stringArrayAsType(meta.queries.map(q => q.propertyName)),
     ];
 }
@@ -19054,6 +19059,7 @@ function createDirectiveType(meta) {
     // so that future fields align.
     typeParams.push(NONE_TYPE);
     typeParams.push(expressionType(literal(meta.isStandalone)));
+    typeParams.push(createHostDirectivesType(meta));
     return expressionType(importExpr(Identifiers.DirectiveDeclaration, typeParams));
 }
 // Define and update any view queries
@@ -19357,6 +19363,68 @@ function compileStyles(styles, selector, hostSelector) {
         return shadowCss.shimCssText(style, selector, hostSelector);
     });
 }
+function createHostDirectivesType(meta) {
+    if (!meta.hostDirectives?.length) {
+        return NONE_TYPE;
+    }
+    return expressionType(literalArr(meta.hostDirectives.map(hostMeta => literalMap([
+        { key: 'directive', value: typeofExpr(hostMeta.directive.type), quoted: false },
+        { key: 'inputs', value: stringMapAsLiteralExpression(hostMeta.inputs || {}), quoted: false },
+        { key: 'outputs', value: stringMapAsLiteralExpression(hostMeta.outputs || {}), quoted: false },
+    ]))));
+}
+function createHostDirectivesFeatureArg(hostDirectives) {
+    const expressions = [];
+    let hasForwardRef = false;
+    for (const current of hostDirectives) {
+        // Use a shorthand if there are no inputs or outputs.
+        if (!current.inputs && !current.outputs) {
+            expressions.push(current.directive.type);
+        }
+        else {
+            const keys = [{ key: 'directive', value: current.directive.type, quoted: false }];
+            if (current.inputs) {
+                const inputsLiteral = createHostDirectivesMappingArray(current.inputs);
+                if (inputsLiteral) {
+                    keys.push({ key: 'inputs', value: inputsLiteral, quoted: false });
+                }
+            }
+            if (current.outputs) {
+                const outputsLiteral = createHostDirectivesMappingArray(current.outputs);
+                if (outputsLiteral) {
+                    keys.push({ key: 'outputs', value: outputsLiteral, quoted: false });
+                }
+            }
+            expressions.push(literalMap(keys));
+        }
+        if (current.isForwardReference) {
+            hasForwardRef = true;
+        }
+    }
+    // If there's a forward reference, we generate a `function() { return [HostDir] }`,
+    // otherwise we can save some bytes by using a plain array, e.g. `[HostDir]`.
+    return hasForwardRef ?
+        new FunctionExpr([], [new ReturnStatement(literalArr(expressions))]) :
+        literalArr(expressions);
+}
+/**
+ * Converts an input/output mapping object literal into an array where the even keys are the
+ * public name of the binding and the odd ones are the name it was aliased to. E.g.
+ * `{inputOne: 'aliasOne', inputTwo: 'aliasTwo'}` will become
+ * `['inputOne', 'aliasOne', 'inputTwo', 'aliasTwo']`.
+ *
+ * This conversion is necessary, because hosts bind to the public name of the host directive and
+ * keeping the mapping in an object literal will break for apps using property renaming.
+ */
+function createHostDirectivesMappingArray(mapping) {
+    const elements = [];
+    for (const publicName in mapping) {
+        if (mapping.hasOwnProperty(publicName)) {
+            elements.push(literal(publicName), literal(mapping[publicName]));
+        }
+    }
+    return elements.length > 0 ? literalArr(elements) : null;
+}
 
 /**
  * @license
@@ -19638,6 +19706,7 @@ function convertDirectiveFacadeToMetadata(facade) {
         providers: facade.providers != null ? new WrappedNodeExpr(facade.providers) : null,
         viewQueries: facade.viewQueries.map(convertToR3QueryMetadata),
         fullInheritance: false,
+        hostDirectives: convertHostDirectivesToMetadata(facade),
     };
 }
 function convertDeclareDirectiveFacadeToMetadata(declaration, typeSourceSpan) {
@@ -19661,6 +19730,7 @@ function convertDeclareDirectiveFacadeToMetadata(declaration, typeSourceSpan) {
         typeArgumentCount: 0,
         fullInheritance: false,
         isStandalone: declaration.isStandalone ?? false,
+        hostDirectives: convertHostDirectivesToMetadata(declaration),
     };
 }
 function convertHostDeclarationToMetadata(host = {}) {
@@ -19674,6 +19744,26 @@ function convertHostDeclarationToMetadata(host = {}) {
         },
     };
 }
+function convertHostDirectivesToMetadata(metadata) {
+    if (metadata.hostDirectives?.length) {
+        return metadata.hostDirectives.map(hostDirective => {
+            return typeof hostDirective === 'function' ?
+                {
+                    directive: wrapReference(hostDirective),
+                    inputs: null,
+                    outputs: null,
+                    isForwardReference: false
+                } :
+                {
+                    directive: wrapReference(hostDirective.directive),
+                    isForwardReference: false,
+                    inputs: hostDirective.inputs ? parseInputOutputs(hostDirective.inputs) : null,
+                    outputs: hostDirective.outputs ? parseInputOutputs(hostDirective.outputs) : null,
+                };
+        });
+    }
+    return null;
+}
 function convertOpaqueValuesToExpressions(obj) {
     const result = {};
     for (const key of Object.keys(obj)) {
@@ -19904,7 +19994,7 @@ function publishFacade(global) {
  * 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 = new Version('14.2.0');
+const VERSION = new Version('15.0.0-next.1');
 
 /**
  * @license
@@ -21606,7 +21696,7 @@ class DirectiveBinder {
         const cssSelector = createCssSelector(elementName, getAttrsForDirectiveMatching(node));
         // Next, use the `SelectorMatcher` to get the list of directives on the node.
         const directives = [];
-        this.matcher.match(cssSelector, (_, directive) => directives.push(directive));
+        this.matcher.match(cssSelector, (_selector, results) => directives.push(...results));
         if (directives.length > 0) {
             this.directives.set(node, directives);
         }
@@ -21937,7 +22027,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$6 = '12.0.0';
 function compileDeclareClassMetadata(metadata) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$6));
-    definitionMap.set('version', literal('14.2.0'));
+    definitionMap.set('version', literal('15.0.0-next.1'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -22054,7 +22144,7 @@ function compileDeclareDirectiveFromMetadata(meta) {
 function createDirectiveDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-    definitionMap.set('version', literal('14.2.0'));
+    definitionMap.set('version', literal('15.0.0-next.1'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.internalType);
     if (meta.isStandalone) {
@@ -22083,6 +22173,9 @@ function createDirectiveDefinitionMap(meta) {
     if (meta.lifecycle.usesOnChanges) {
         definitionMap.set('usesOnChanges', literal(true));
     }
+    if (meta.hostDirectives?.length) {
+        definitionMap.set('hostDirectives', createHostDirectives(meta.hostDirectives));
+    }
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     return definitionMap;
 }
@@ -22137,6 +22230,28 @@ function compileHostMetadata(meta) {
         return null;
     }
 }
+function createHostDirectives(hostDirectives) {
+    const expressions = hostDirectives.map(current => {
+        const keys = [{
+                key: 'directive',
+                value: current.isForwardReference ? generateForwardRef(current.directive.type) :
+                    current.directive.type,
+                quoted: false
+            }];
+        const inputsLiteral = current.inputs ? createHostDirectivesMappingArray(current.inputs) : null;
+        const outputsLiteral = current.outputs ? createHostDirectivesMappingArray(current.outputs) : null;
+        if (inputsLiteral) {
+            keys.push({ key: 'inputs', value: inputsLiteral, quoted: false });
+        }
+        if (outputsLiteral) {
+            keys.push({ key: 'outputs', value: outputsLiteral, quoted: false });
+        }
+        return literalMap(keys);
+    });
+    // If there's a forward reference, we generate a `function() { return [{directive: HostDir}] }`,
+    // otherwise we can save some bytes by using a plain array, e.g. `[{directive: HostDir}]`.
+    return literalArr(expressions);
+}
 
 /**
  * @license
@@ -22268,7 +22383,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$4 = '12.0.0';
 function compileDeclareFactoryFunction(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$4));
-    definitionMap.set('version', literal('14.2.0'));
+    definitionMap.set('version', literal('15.0.0-next.1'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.internalType);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -22310,7 +22425,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-    definitionMap.set('version', literal('14.2.0'));
+    definitionMap.set('version', literal('15.0.0-next.1'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.internalType);
     // Only generate providedIn property if it has a non-null value
@@ -22368,7 +22483,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-    definitionMap.set('version', literal('14.2.0'));
+    definitionMap.set('version', literal('15.0.0-next.1'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.internalType);
     definitionMap.set('providers', meta.providers);
@@ -22405,7 +22520,7 @@ function compileDeclareNgModuleFromMetadata(meta) {
 function createNgModuleDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-    definitionMap.set('version', literal('14.2.0'));
+    definitionMap.set('version', literal('15.0.0-next.1'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.internalType);
     // We only generate the keys in the metadata if the arrays contain values.
@@ -22463,7 +22578,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', literal('14.2.0'));
+    definitionMap.set('version', literal('15.0.0-next.1'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.internalType);