@angular/compiler 20.0.0-next.8 → 20.0.0-rc.0

package/fesm2022/compiler.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v20.0.0-next.8
+ * @license Angular v20.0.0-rc.0
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -403,7 +403,7 @@ class SelectorlessMatcher {
         this.registry = registry;
     }
     match(name) {
-        return this.registry.get(name) ?? null;
+        return this.registry.has(name) ? this.registry.get(name) : [];
     }
 }
 
@@ -3218,28 +3218,26 @@ function stringify(token) {
         return token;
     }
     if (Array.isArray(token)) {
-        return '[' + token.map(stringify).join(', ') + ']';
+        return `[${token.map(stringify).join(', ')}]`;
     }
     if (token == null) {
         return '' + token;
     }
-    if (token.overriddenName) {
-        return `${token.overriddenName}`;
-    }
-    if (token.name) {
-        return `${token.name}`;
+    const name = token.overriddenName || token.name;
+    if (name) {
+        return `${name}`;
     }
     if (!token.toString) {
         return 'object';
     }
     // WARNING: do not try to `JSON.stringify(token)` here
     // see https://github.com/angular/angular/issues/23440
-    const res = token.toString();
-    if (res == null) {
-        return '' + res;
+    const result = token.toString();
+    if (result == null) {
+        return '' + result;
     }
-    const newLineIndex = res.indexOf('\n');
-    return newLineIndex === -1 ? res : res.substring(0, newLineIndex);
+    const newLineIndex = result.indexOf('\n');
+    return newLineIndex >= 0 ? result.slice(0, newLineIndex) : result;
 }
 class Version {
     full;
@@ -26448,6 +26446,7 @@ function ingestNodes(unit, template) {
         else if (node instanceof LetDeclaration$1) {
             ingestLetDeclaration(unit, node);
         }
+        else if (node instanceof Component$1) ;
         else {
             throw new Error(`Unsupported template node: ${node.constructor.name}`);
         }
@@ -30509,6 +30508,7 @@ class R3TargetBinder {
         }
         const directives = new Map();
         const eagerDirectives = [];
+        const missingDirectives = new Set();
         const bindings = new Map();
         const references = new Map();
         const scopedNodeEntities = new Map();
@@ -30529,7 +30529,9 @@ class R3TargetBinder {
             //   - bindings: Map of inputs, outputs, and attributes to the directive/element that claims
             //     them. TODO(alxhub): handle multiple directives claiming an input/output/etc.
             //   - references: Map of #references to their targets.
-            DirectiveBinder.apply(target.template, this.directiveMatcher, directives, eagerDirectives, bindings, references);
+            if (this.directiveMatcher !== null) {
+                DirectiveBinder.apply(target.template, this.directiveMatcher, directives, eagerDirectives, missingDirectives, bindings, references);
+            }
             // Finally, run the TemplateBinder to bind references, variables, and other entities within the
             // template. This extracts all the metadata that doesn't depend on directive matching.
             TemplateBinder.applyWithScope(target.template, scope, expressions, symbols, nestingLevel, usedPipes, eagerPipes, deferBlocks);
@@ -30539,7 +30541,7 @@ class R3TargetBinder {
         if (target.host) {
             TemplateBinder.applyWithScope(target.host, Scope.apply(target.host), expressions, symbols, nestingLevel, usedPipes, eagerPipes, deferBlocks);
         }
-        return new R3BoundTarget(target, directives, eagerDirectives, bindings, references, expressions, symbols, nestingLevel, scopedNodeEntities, usedPipes, eagerPipes, deferBlocks);
+        return new R3BoundTarget(target, directives, eagerDirectives, missingDirectives, bindings, references, expressions, symbols, nestingLevel, scopedNodeEntities, usedPipes, eagerPipes, deferBlocks);
     }
 }
 /**
@@ -30751,14 +30753,16 @@ class DirectiveBinder {
     directiveMatcher;
     directives;
     eagerDirectives;
+    missingDirectives;
     bindings;
     references;
     // Indicates whether we are visiting elements within a `defer` block
     isInDeferBlock = false;
-    constructor(directiveMatcher, directives, eagerDirectives, bindings, references) {
+    constructor(directiveMatcher, directives, eagerDirectives, missingDirectives, bindings, references) {
         this.directiveMatcher = directiveMatcher;
         this.directives = directives;
         this.eagerDirectives = eagerDirectives;
+        this.missingDirectives = missingDirectives;
         this.bindings = bindings;
         this.references = references;
     }
@@ -30774,8 +30778,8 @@ class DirectiveBinder {
      * map which resolves #references (`Reference`s) within the template to the named directive or
      * template node.
      */
-    static apply(template, directiveMatcher, directives, eagerDirectives, bindings, references) {
-        const matcher = new DirectiveBinder(directiveMatcher, directives, eagerDirectives, bindings, references);
+    static apply(template, directiveMatcher, directives, eagerDirectives, missingDirectives, bindings, references) {
+        const matcher = new DirectiveBinder(directiveMatcher, directives, eagerDirectives, missingDirectives, bindings, references);
         matcher.ingest(template);
     }
     ingest(template) {
@@ -30831,55 +30835,36 @@ class DirectiveBinder {
         content.children.forEach((child) => child.visit(this));
     }
     visitComponent(node) {
-        const directives = [];
-        let componentMetas = null;
         if (this.directiveMatcher instanceof SelectorlessMatcher) {
-            componentMetas = this.directiveMatcher.match(node.componentName);
-            if (componentMetas !== null) {
-                directives.push(...componentMetas);
+            const componentMatches = this.directiveMatcher.match(node.componentName);
+            if (componentMatches.length > 0) {
+                this.trackSelectorlessMatchesAndDirectives(node, componentMatches);
             }
-            for (const directive of node.directives) {
-                const directiveMetas = this.directiveMatcher.match(directive.name);
-                if (directiveMetas !== null) {
-                    directives.push(...directiveMetas);
-                }
+            else {
+                this.missingDirectives.add(node.componentName);
             }
         }
-        this.trackMatchedDirectives(node, directives);
-        if (componentMetas !== null) {
-            this.trackSelectorlessBindings(node, componentMetas);
-        }
         node.directives.forEach((directive) => directive.visit(this));
         node.children.forEach((child) => child.visit(this));
     }
     visitDirective(node) {
-        const directives = this.directiveMatcher instanceof SelectorlessMatcher
-            ? this.directiveMatcher.match(node.name)
-            : null;
-        if (directives !== null) {
-            this.trackSelectorlessBindings(node, directives);
+        if (this.directiveMatcher instanceof SelectorlessMatcher) {
+            const directives = this.directiveMatcher.match(node.name);
+            if (directives.length > 0) {
+                this.trackSelectorlessMatchesAndDirectives(node, directives);
+            }
+            else {
+                this.missingDirectives.add(node.name);
+            }
         }
     }
     visitElementOrTemplate(node) {
-        const directives = [];
         if (this.directiveMatcher instanceof SelectorMatcher) {
-            // First, determine the HTML shape of the node for the purpose of directive matching.
-            // Do this by building up a `CssSelector` for the node.
+            const directives = [];
             const cssSelector = createCssSelectorFromNode(node);
-            this.directiveMatcher.match(cssSelector, (_selector, results) => {
-                directives.push(...results);
-            });
-            this.trackSelectorMatchedBindings(node, directives);
-        }
-        else {
-            for (const directive of node.directives) {
-                const matchedDirectives = this.directiveMatcher.match(directive.name);
-                if (matchedDirectives !== null) {
-                    directives.push(...matchedDirectives);
-                }
-            }
+            this.directiveMatcher.match(cssSelector, (_, results) => directives.push(...results));
+            this.trackSelectorBasedBindingsAndDirectives(node, directives);
         }
-        this.trackMatchedDirectives(node, directives);
         node.directives.forEach((directive) => directive.visit(this));
         node.children.forEach((child) => child.visit(this));
     }
@@ -30891,25 +30876,28 @@ class DirectiveBinder {
             }
         }
     }
-    trackSelectorlessBindings(node, metas) {
+    trackSelectorlessMatchesAndDirectives(node, directives) {
+        if (directives.length === 0) {
+            return;
+        }
+        this.trackMatchedDirectives(node, directives);
         const setBinding = (meta, attribute, ioType) => {
             if (meta[ioType].hasBindingPropertyName(attribute.name)) {
                 this.bindings.set(attribute, meta);
             }
         };
-        for (const meta of metas) {
-            node.inputs.forEach((input) => setBinding(meta, input, 'inputs'));
-            node.attributes.forEach((attr) => setBinding(meta, attr, 'inputs'));
-            node.outputs.forEach((output) => setBinding(meta, output, 'outputs'));
+        for (const directive of directives) {
+            node.inputs.forEach((input) => setBinding(directive, input, 'inputs'));
+            node.attributes.forEach((attr) => setBinding(directive, attr, 'inputs'));
+            node.outputs.forEach((output) => setBinding(directive, output, 'outputs'));
         }
         // TODO(crisbeto): currently it's unclear how references should behave under selectorless,
         // given that there's one named class which can bring in multiple host directives.
         // For the time being only register the first directive as the reference target.
-        if (metas.length > 0) {
-            node.references.forEach((ref) => this.references.set(ref, { directive: metas[0], node: node }));
-        }
+        node.references.forEach((ref) => this.references.set(ref, { directive: directives[0], node: node }));
     }
-    trackSelectorMatchedBindings(node, directives) {
+    trackSelectorBasedBindingsAndDirectives(node, directives) {
+        this.trackMatchedDirectives(node, directives);
         // Resolve any references that are created on this node.
         node.references.forEach((ref) => {
             let dirTarget = null;
@@ -31243,6 +31231,7 @@ class R3BoundTarget {
     target;
     directives;
     eagerDirectives;
+    missingDirectives;
     bindings;
     references;
     exprTargets;
@@ -31255,10 +31244,11 @@ class R3BoundTarget {
     deferredBlocks;
     /** Map of deferred blocks to their scope. */
     deferredScopes;
-    constructor(target, directives, eagerDirectives, bindings, references, exprTargets, symbols, nestingLevel, scopedNodeEntities, usedPipes, eagerPipes, rawDeferred) {
+    constructor(target, directives, eagerDirectives, missingDirectives, bindings, references, exprTargets, symbols, nestingLevel, scopedNodeEntities, usedPipes, eagerPipes, rawDeferred) {
         this.target = target;
         this.directives = directives;
         this.eagerDirectives = eagerDirectives;
+        this.missingDirectives = missingDirectives;
         this.bindings = bindings;
         this.references = references;
         this.exprTargets = exprTargets;
@@ -31374,6 +31364,9 @@ class R3BoundTarget {
         }
         return false;
     }
+    referencedDirectiveExists(name) {
+        return !this.missingDirectives.has(name);
+    }
     /**
      * Finds an entity with a specific name in a scope.
      * @param rootNode Root node of the scope.
@@ -31876,7 +31869,7 @@ function parseJitTemplate(template, typeName, sourceMapUrl, preserveWhitespaces,
         const errors = parsed.errors.map((err) => err.toString()).join(', ');
         throw new Error(`Errors during JIT compilation of template for ${typeName}: ${errors}`);
     }
-    const binder = new R3TargetBinder(new SelectorMatcher());
+    const binder = new R3TargetBinder(null);
     const boundTarget = binder.bind({ template: parsed.nodes });
     return {
         template: parsed,
@@ -33875,7 +33868,7 @@ const MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION = '18.0.0';
 function compileDeclareClassMetadata(metadata) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-    definitionMap.set('version', literal('20.0.0-next.8'));
+    definitionMap.set('version', literal('20.0.0-rc.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -33893,7 +33886,7 @@ function compileComponentDeclareClassMetadata(metadata, dependencies) {
     callbackReturnDefinitionMap.set('ctorParameters', metadata.ctorParameters ?? literal(null));
     callbackReturnDefinitionMap.set('propDecorators', metadata.propDecorators ?? literal(null));
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION));
-    definitionMap.set('version', literal('20.0.0-next.8'));
+    definitionMap.set('version', literal('20.0.0-rc.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('resolveDeferredDeps', compileComponentMetadataAsyncResolver(dependencies));
@@ -33988,7 +33981,7 @@ function createDirectiveDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     const minVersion = getMinimumVersionForPartialOutput(meta);
     definitionMap.set('minVersion', literal(minVersion));
-    definitionMap.set('version', literal('20.0.0-next.8'));
+    definitionMap.set('version', literal('20.0.0-rc.0'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone !== undefined) {
@@ -34404,7 +34397,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('20.0.0-next.8'));
+    definitionMap.set('version', literal('20.0.0-rc.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -34439,7 +34432,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-    definitionMap.set('version', literal('20.0.0-next.8'));
+    definitionMap.set('version', literal('20.0.0-rc.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
@@ -34490,7 +34483,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-    definitionMap.set('version', literal('20.0.0-next.8'));
+    definitionMap.set('version', literal('20.0.0-rc.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -34523,7 +34516,7 @@ function createNgModuleDefinitionMap(meta) {
         throw new Error('Invalid path! Local compilation mode should not get into the partial compilation path');
     }
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-    definitionMap.set('version', literal('20.0.0-next.8'));
+    definitionMap.set('version', literal('20.0.0-rc.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // We only generate the keys in the metadata if the arrays contain values.
@@ -34574,7 +34567,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', literal('20.0.0-next.8'));
+    definitionMap.set('version', literal('20.0.0-rc.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);
@@ -34732,7 +34725,7 @@ function compileHmrUpdateCallback(definitions, constantStatements, meta) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-const VERSION = new Version('20.0.0-next.8');
+const VERSION = new Version('20.0.0-rc.0');
 
 //////////////////////////////////////
 // THIS FILE HAS GLOBAL SIDE EFFECT //