@angular/compiler 16.2.2 → 17.0.0-next.1

package/esm2022/src/render3/r3_class_metadata_compiler.mjs

@@ -20,4 +20,58 @@ export function compileClassMetadata(metadata) {
     const iife = o.fn([], [devOnlyGuardedExpression(fnCall).toStmt()]);
     return iife.callFn([]);
 }
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Wraps the `setClassMetadata` function with extra logic that dynamically
+ * loads dependencies from `{#defer}` blocks.
+ *
+ * Generates a call like this:
+ * ```
+ * setClassMetadataAsync(type, () => {
+ *   return [
+ *     import('./cmp-a').then(m => m.CmpA);
+ *     import('./cmp-b').then(m => m.CmpB);
+ *   ];
+ * }, (CmpA, CmpB) => {
+ *   setClassMetadata(type, decorators, ctorParameters, propParameters);
+ * });
+ * ```
+ *
+ * Similar to the `setClassMetadata` call, it's wrapped into the `ngDevMode`
+ * check to tree-shake away this code in production mode.
+ */
+export function compileComponentClassMetadata(metadata, deferrableTypes) {
+    if (deferrableTypes.size === 0) {
+        // If there are no deferrable symbols - just generate a regular `setClassMetadata` call.
+        return compileClassMetadata(metadata);
+    }
+    const dynamicImports = [];
+    const importedSymbols = [];
+    for (const [symbolName, importPath] of deferrableTypes) {
+        // e.g. `function(m) { return m.CmpA; }`
+        const innerFn = o.fn([new o.FnParam('m', o.DYNAMIC_TYPE)], [new o.ReturnStatement(o.variable('m').prop(symbolName))]);
+        // e.g. `import('./cmp-a').then(...)`
+        const importExpr = (new o.DynamicImportExpr(importPath)).prop('then').callFn([innerFn]);
+        dynamicImports.push(importExpr);
+        importedSymbols.push(new o.FnParam(symbolName, o.DYNAMIC_TYPE));
+    }
+    // e.g. `function() { return [ ... ]; }`
+    const dependencyLoadingFn = o.fn([], [new o.ReturnStatement(o.literalArr(dynamicImports))]);
+    // e.g. `setClassMetadata(...)`
+    const setClassMetadataCall = o.importExpr(R3.setClassMetadata).callFn([
+        metadata.type,
+        metadata.decorators,
+        metadata.ctorParameters ?? o.literal(null),
+        metadata.propDecorators ?? o.literal(null),
+    ]);
+    // e.g. `function(CmpA) { setClassMetadata(...); }`
+    const setClassMetaWrapper = o.fn(importedSymbols, [setClassMetadataCall.toStmt()]);
+    // Final `setClassMetadataAsync()` call with all arguments
+    const setClassMetaAsync = o.importExpr(R3.setClassMetadataAsync).callFn([
+        metadata.type, dependencyLoadingFn, setClassMetaWrapper
+    ]);
+    // Generate an ngDevMode guarded call to `setClassMetadataAsync` with
+    // the class identifier and its metadata, so that this call can be tree-shaken.
+    const iife = o.fn([], [devOnlyGuardedExpression(setClassMetaAsync).toStmt()]);
+    return iife.callFn([]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"r3_class_metadata_compiler.js","sourceRoot":"","sources":["../../../../../../../packages/compiler/src/render3/r3_class_metadata_compiler.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport * as o from '../output/output_ast';\n\nimport {Identifiers as R3} from './r3_identifiers';\nimport {devOnlyGuardedExpression} from './util';\n\nexport type CompileClassMetadataFn = (metadata: R3ClassMetadata) => o.Expression;\n\n/**\n * Metadata of a class which captures the original Angular decorators of a class. The original\n * decorators are preserved in the generated code to allow TestBed APIs to recompile the class\n * using the original decorator with a set of overrides applied.\n */\nexport interface R3ClassMetadata {\n  /**\n   * The class type for which the metadata is captured.\n   */\n  type: o.Expression;\n\n  /**\n   * An expression representing the Angular decorators that were applied on the class.\n   */\n  decorators: o.Expression;\n\n  /**\n   * An expression representing the Angular decorators applied to constructor parameters, or `null`\n   * if there is no constructor.\n   */\n  ctorParameters: o.Expression|null;\n\n  /**\n   * An expression representing the Angular decorators that were applied on the properties of the\n   * class, or `null` if no properties have decorators.\n   */\n  propDecorators: o.Expression|null;\n}\n\nexport function compileClassMetadata(metadata: R3ClassMetadata): o.Expression {\n  // Generate an ngDevMode guarded call to setClassMetadata with the class identifier and its\n  // metadata.\n  const fnCall = o.importExpr(R3.setClassMetadata).callFn([\n    metadata.type,\n    metadata.decorators,\n    metadata.ctorParameters ?? o.literal(null),\n    metadata.propDecorators ?? o.literal(null),\n  ]);\n  const iife = o.fn([], [devOnlyGuardedExpression(fnCall).toStmt()]);\n  return iife.callFn([]);\n}\n\n/**\n * Wraps the `setClassMetadata` function with extra logic that dynamically\n * loads dependencies from `{#defer}` blocks.\n *\n * Generates a call like this:\n * ```\n * setClassMetadataAsync(type, () => {\n *   return [\n *     import('./cmp-a').then(m => m.CmpA);\n *     import('./cmp-b').then(m => m.CmpB);\n *   ];\n * }, (CmpA, CmpB) => {\n *   setClassMetadata(type, decorators, ctorParameters, propParameters);\n * });\n * ```\n *\n * Similar to the `setClassMetadata` call, it's wrapped into the `ngDevMode`\n * check to tree-shake away this code in production mode.\n */\nexport function compileComponentClassMetadata(\n    metadata: R3ClassMetadata, deferrableTypes: Map<string, string>): o.Expression {\n  if (deferrableTypes.size === 0) {\n    // If there are no deferrable symbols - just generate a regular `setClassMetadata` call.\n    return compileClassMetadata(metadata);\n  }\n\n  const dynamicImports: o.Expression[] = [];\n  const importedSymbols: o.FnParam[] = [];\n  for (const [symbolName, importPath] of deferrableTypes) {\n    // e.g. `function(m) { return m.CmpA; }`\n    const innerFn = o.fn(\n        [new o.FnParam('m', o.DYNAMIC_TYPE)],\n        [new o.ReturnStatement(o.variable('m').prop(symbolName))]);\n\n    // e.g. `import('./cmp-a').then(...)`\n    const importExpr = (new o.DynamicImportExpr(importPath)).prop('then').callFn([innerFn]);\n\n    dynamicImports.push(importExpr);\n    importedSymbols.push(new o.FnParam(symbolName, o.DYNAMIC_TYPE));\n  }\n\n  // e.g. `function() { return [ ... ]; }`\n  const dependencyLoadingFn = o.fn([], [new o.ReturnStatement(o.literalArr(dynamicImports))]);\n\n  // e.g. `setClassMetadata(...)`\n  const setClassMetadataCall = o.importExpr(R3.setClassMetadata).callFn([\n    metadata.type,\n    metadata.decorators,\n    metadata.ctorParameters ?? o.literal(null),\n    metadata.propDecorators ?? o.literal(null),\n  ]);\n\n  // e.g. `function(CmpA) { setClassMetadata(...); }`\n  const setClassMetaWrapper = o.fn(importedSymbols, [setClassMetadataCall.toStmt()]);\n\n  // Final `setClassMetadataAsync()` call with all arguments\n  const setClassMetaAsync = o.importExpr(R3.setClassMetadataAsync).callFn([\n    metadata.type, dependencyLoadingFn, setClassMetaWrapper\n  ]);\n\n  // Generate an ngDevMode guarded call to `setClassMetadataAsync` with\n  // the class identifier and its metadata, so that this call can be tree-shaken.\n  const iife = o.fn([], [devOnlyGuardedExpression(setClassMetaAsync).toStmt()]);\n  return iife.callFn([]);\n}\n"]}

package/esm2022/src/render3/r3_control_flow.mjs

@@ -0,0 +1,332 @@
+/**
+ * @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
+ */
+import * as html from '../ml_parser/ast';
+import { ParseError } from '../parse_util';
+import * as t from './r3_ast';
+/** Pattern for the expression in a for loop block. */
+const FOR_LOOP_EXPRESSION_PATTERN = /^\s*([0-9A-Za-z_$]*)\s+of\s+(.*)/;
+/** Pattern for the tracking expression in a for loop block. */
+const FOR_LOOP_TRACK_PATTERN = /^track\s+(.*)/;
+/** Pattern for the `as` expression in a conditional block. */
+const CONDITIONAL_ALIAS_PATTERN = /^as\s+(.*)/;
+/** Pattern used to identify an `else if` block. */
+const ELSE_IF_PATTERN = /^if\s/;
+/** Pattern used to identify a `let` parameter. */
+const FOR_LOOP_LET_PATTERN = /^let\s+(.*)/;
+/** Names of variables that are allowed to be used in the `let` expression of a `for` loop. */
+const ALLOWED_FOR_LOOP_LET_VARIABLES = new Set(['$index', '$first', '$last', '$even', '$odd', '$count']);
+/** Creates an `if` loop block from an HTML AST node. */
+export function createIfBlock(ast, visitor, bindingParser) {
+    const errors = validateIfBlock(ast);
+    const branches = [];
+    if (errors.length > 0) {
+        return { node: null, errors };
+    }
+    // Assumes that the structure is valid since we validated it above.
+    for (const block of ast.blocks) {
+        const children = html.visitAll(visitor, block.children);
+        // `{:else}` block.
+        if (block.name === 'else' && block.parameters.length === 0) {
+            branches.push(new t.IfBlockBranch(null, children, null, block.sourceSpan, block.startSourceSpan));
+            continue;
+        }
+        const params = parseConditionalBlockParameters(block, errors, bindingParser);
+        if (params !== null) {
+            branches.push(new t.IfBlockBranch(params.expression, children, params.expressionAlias, block.sourceSpan, block.startSourceSpan));
+        }
+    }
+    return {
+        node: new t.IfBlock(branches, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan),
+        errors,
+    };
+}
+/** Creates a `for` loop block from an HTML AST node. */
+export function createForLoop(ast, visitor, bindingParser) {
+    const [primaryBlock, ...secondaryBlocks] = ast.blocks;
+    const errors = [];
+    const params = parseForLoopParameters(primaryBlock, errors, bindingParser);
+    let node = null;
+    let empty = null;
+    for (const block of secondaryBlocks) {
+        if (block.name === 'empty') {
+            if (empty !== null) {
+                errors.push(new ParseError(block.sourceSpan, 'For loop can only have one "empty" block'));
+            }
+            else if (block.parameters.length > 0) {
+                errors.push(new ParseError(block.sourceSpan, 'Empty block cannot have parameters'));
+            }
+            else {
+                empty = new t.ForLoopBlockEmpty(html.visitAll(visitor, block.children), block.sourceSpan, block.startSourceSpan);
+            }
+        }
+        else {
+            errors.push(new ParseError(block.sourceSpan, `Unrecognized loop block "${block.name}"`));
+        }
+    }
+    if (params !== null) {
+        if (params.trackBy === null) {
+            errors.push(new ParseError(ast.sourceSpan, 'For loop must have a "track" expression'));
+        }
+        else {
+            node = new t.ForLoopBlock(params.itemName, params.expression, params.trackBy, params.context, html.visitAll(visitor, primaryBlock.children), empty, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan);
+        }
+    }
+    return { node, errors };
+}
+/** Creates a switch block from an HTML AST node. */
+export function createSwitchBlock(ast, visitor, bindingParser) {
+    const [primaryBlock, ...secondaryBlocks] = ast.blocks;
+    const errors = validateSwitchBlock(ast);
+    if (errors.length > 0) {
+        return { node: null, errors };
+    }
+    const primaryExpression = parseBlockParameterToBinding(primaryBlock.parameters[0], bindingParser);
+    const cases = [];
+    let defaultCase = null;
+    // Here we assume that all the blocks are valid given that we validated them above.
+    for (const block of secondaryBlocks) {
+        const expression = block.name === 'case' ?
+            parseBlockParameterToBinding(block.parameters[0], bindingParser) :
+            null;
+        const ast = new t.SwitchBlockCase(expression, html.visitAll(visitor, block.children), block.sourceSpan, block.startSourceSpan);
+        if (expression === null) {
+            defaultCase = ast;
+        }
+        else {
+            cases.push(ast);
+        }
+    }
+    // Ensure that the default case is last in the array.
+    if (defaultCase !== null) {
+        cases.push(defaultCase);
+    }
+    return {
+        node: new t.SwitchBlock(primaryExpression, cases, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan),
+        errors
+    };
+}
+/** Parses the parameters of a `for` loop block. */
+function parseForLoopParameters(block, errors, bindingParser) {
+    if (block.parameters.length === 0) {
+        errors.push(new ParseError(block.sourceSpan, 'For loop does not have an expression'));
+        return null;
+    }
+    const [expressionParam, ...secondaryParams] = block.parameters;
+    const match = stripOptionalParentheses(expressionParam, errors)?.match(FOR_LOOP_EXPRESSION_PATTERN);
+    if (!match || match[2].trim().length === 0) {
+        errors.push(new ParseError(expressionParam.sourceSpan, 'Cannot parse expression. For loop expression must match the pattern "<identifier> of <expression>"'));
+        return null;
+    }
+    const [, itemName, rawExpression] = match;
+    const result = {
+        itemName,
+        trackBy: null,
+        expression: parseBlockParameterToBinding(expressionParam, bindingParser, rawExpression),
+        context: null,
+    };
+    for (const param of secondaryParams) {
+        const letMatch = param.expression.match(FOR_LOOP_LET_PATTERN);
+        if (letMatch !== null) {
+            result.context = result.context || {};
+            parseLetParameter(param.sourceSpan, letMatch[1], result.context, errors);
+            continue;
+        }
+        const trackMatch = param.expression.match(FOR_LOOP_TRACK_PATTERN);
+        if (trackMatch !== null) {
+            if (result.trackBy !== null) {
+                errors.push(new ParseError(param.sourceSpan, 'For loop can only have one "track" expression'));
+            }
+            else {
+                result.trackBy = parseBlockParameterToBinding(param, bindingParser, trackMatch[1]);
+            }
+            continue;
+        }
+        errors.push(new ParseError(param.sourceSpan, `Unrecognized loop paramater "${param.expression}"`));
+    }
+    return result;
+}
+/** Parses the `let` parameter of a `for` loop block. */
+function parseLetParameter(sourceSpan, expression, context, errors) {
+    const parts = expression.split(',');
+    for (const part of parts) {
+        const expressionParts = part.split('=');
+        const name = expressionParts.length === 2 ? expressionParts[0].trim() : '';
+        const variableName = expressionParts.length === 2 ? expressionParts[1].trim() : '';
+        if (name.length === 0 || variableName.length === 0) {
+            errors.push(new ParseError(sourceSpan, `Invalid for loop "let" parameter. Parameter should match the pattern "<name> = <variable name>"`));
+        }
+        else if (!ALLOWED_FOR_LOOP_LET_VARIABLES.has(variableName)) {
+            errors.push(new ParseError(sourceSpan, `Unknown "let" parameter variable "${variableName}". The allowed variables are: ${Array.from(ALLOWED_FOR_LOOP_LET_VARIABLES).join(', ')}`));
+        }
+        else if (context.hasOwnProperty(variableName)) {
+            errors.push(new ParseError(sourceSpan, `Duplicate "let" parameter variable "${variableName}"`));
+        }
+        else {
+            context[variableName] = name;
+        }
+    }
+}
+/** Checks that the shape of a `if` block is valid. Returns an array of errors. */
+function validateIfBlock(ast) {
+    const errors = [];
+    let hasElse = false;
+    for (let i = 0; i < ast.blocks.length; i++) {
+        const block = ast.blocks[i];
+        // Conditional blocks only allow `if`, `else if` and `else` blocks.
+        if ((block.name !== 'if' || i > 0) && block.name !== 'else') {
+            errors.push(new ParseError(block.sourceSpan, `Unrecognized conditional block "${block.name}"`));
+            continue;
+        }
+        if (block.name === 'if') {
+            continue;
+        }
+        if (block.parameters.length === 0) {
+            if (hasElse) {
+                errors.push(new ParseError(block.sourceSpan, 'Conditional can only have one "else" block'));
+            }
+            else if (ast.blocks.length > 1 && i < ast.blocks.length - 1) {
+                errors.push(new ParseError(block.sourceSpan, 'Else block must be last inside the conditional'));
+            }
+            hasElse = true;
+            // `else if` is an edge case, because it has a space after the block name
+            // which means that the `if` is captured as a part of the parameters.
+        }
+        else if (block.parameters.length > 0 && !ELSE_IF_PATTERN.test(block.parameters[0].expression)) {
+            errors.push(new ParseError(block.sourceSpan, 'Else block cannot have parameters'));
+        }
+    }
+    return errors;
+}
+/** Checks that the shape of a `switch` block is valid. Returns an array of errors. */
+function validateSwitchBlock(ast) {
+    const [primaryBlock, ...secondaryBlocks] = ast.blocks;
+    const errors = [];
+    let hasDefault = false;
+    if (primaryBlock.children.length > 0) {
+        errors.push(new ParseError(primaryBlock.sourceSpan, 'Switch block can only contain "case" and "default" blocks'));
+    }
+    if (primaryBlock.parameters.length !== 1) {
+        errors.push(new ParseError(primaryBlock.sourceSpan, 'Switch block must have exactly one parameter'));
+    }
+    for (const block of secondaryBlocks) {
+        if (block.name === 'case') {
+            if (block.parameters.length !== 1) {
+                errors.push(new ParseError(block.sourceSpan, 'Case block must have exactly one parameter'));
+            }
+        }
+        else if (block.name === 'default') {
+            if (hasDefault) {
+                errors.push(new ParseError(block.sourceSpan, 'Switch block can only have one "default" block'));
+            }
+            else if (block.parameters.length > 0) {
+                errors.push(new ParseError(block.sourceSpan, 'Default block cannot have parameters'));
+            }
+            hasDefault = true;
+        }
+        else {
+            errors.push(new ParseError(block.sourceSpan, 'Switch block can only contain "case" and "default" blocks'));
+        }
+    }
+    return errors;
+}
+function parseBlockParameterToBinding(ast, bindingParser, part = 0) {
+    let start;
+    let end;
+    if (typeof part === 'number') {
+        start = part;
+        end = ast.expression.length;
+    }
+    else {
+        // Note: `lastIndexOf` here should be enough to know the start index of the expression,
+        // because we know that it'll be at the end of the param. Ideally we could use the `d`
+        // flag when matching via regex and get the index from `match.indices`, but it's unclear
+        // if we can use it yet since it's a relatively new feature. See:
+        // https://github.com/tc39/proposal-regexp-match-indices
+        start = Math.max(0, ast.expression.lastIndexOf(part));
+        end = start + part.length;
+    }
+    return bindingParser.parseBinding(ast.expression.slice(start, end), false, ast.sourceSpan, ast.sourceSpan.start.offset + start);
+}
+/** Parses the parameter of a conditional block (`if` or `else if`). */
+function parseConditionalBlockParameters(block, errors, bindingParser) {
+    if (block.parameters.length === 0) {
+        errors.push(new ParseError(block.sourceSpan, 'Conditional block does not have an expression'));
+        return null;
+    }
+    const isPrimaryIfBlock = block.name === 'if';
+    const expression = 
+    // Expressions for `{:else if}` blocks start at 2 to skip the `if` from the expression.
+    parseBlockParameterToBinding(block.parameters[0], bindingParser, isPrimaryIfBlock ? 0 : 2);
+    let expressionAlias = null;
+    // Start from 1 since we processed the first parameter already.
+    for (let i = 1; i < block.parameters.length; i++) {
+        const param = block.parameters[i];
+        const aliasMatch = param.expression.match(CONDITIONAL_ALIAS_PATTERN);
+        // For now conditionals can only have an `as` parameter.
+        // We may want to rework this later if we add more.
+        if (aliasMatch === null) {
+            errors.push(new ParseError(param.sourceSpan, `Unrecognized conditional paramater "${param.expression}"`));
+        }
+        else if (!isPrimaryIfBlock) {
+            errors.push(new ParseError(param.sourceSpan, '"as" expression is only allowed on the primary "if" block'));
+        }
+        else if (expressionAlias !== null) {
+            errors.push(new ParseError(param.sourceSpan, 'Conditional can only have one "as" expression'));
+        }
+        else {
+            expressionAlias = aliasMatch[1].trim();
+        }
+    }
+    return { expression, expressionAlias };
+}
+/** Strips optional parentheses around from a control from expression parameter. */
+function stripOptionalParentheses(param, errors) {
+    const expression = param.expression;
+    const spaceRegex = /^\s$/;
+    let openParens = 0;
+    let start = 0;
+    let end = expression.length - 1;
+    for (let i = 0; i < expression.length; i++) {
+        const char = expression[i];
+        if (char === '(') {
+            start = i + 1;
+            openParens++;
+        }
+        else if (spaceRegex.test(char)) {
+            continue;
+        }
+        else {
+            break;
+        }
+    }
+    if (openParens === 0) {
+        return expression;
+    }
+    for (let i = expression.length - 1; i > -1; i--) {
+        const char = expression[i];
+        if (char === ')') {
+            end = i;
+            openParens--;
+            if (openParens === 0) {
+                break;
+            }
+        }
+        else if (spaceRegex.test(char)) {
+            continue;
+        }
+        else {
+            break;
+        }
+    }
+    if (openParens !== 0) {
+        errors.push(new ParseError(param.sourceSpan, 'Unclosed parentheses in expression'));
+        return null;
+    }
+    return expression.slice(start, end);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"r3_control_flow.js","sourceRoot":"","sources":["../../../../../../../packages/compiler/src/render3/r3_control_flow.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {ASTWithSource} from '../expression_parser/ast';\nimport * as html from '../ml_parser/ast';\nimport {ParseError, ParseSourceSpan} from '../parse_util';\nimport {BindingParser} from '../template_parser/binding_parser';\n\nimport * as t from './r3_ast';\n\n/** Pattern for the expression in a for loop block. */\nconst FOR_LOOP_EXPRESSION_PATTERN = /^\\s*([0-9A-Za-z_$]*)\\s+of\\s+(.*)/;\n\n/** Pattern for the tracking expression in a for loop block. */\nconst FOR_LOOP_TRACK_PATTERN = /^track\\s+(.*)/;\n\n/** Pattern for the `as` expression in a conditional block. */\nconst CONDITIONAL_ALIAS_PATTERN = /^as\\s+(.*)/;\n\n/** Pattern used to identify an `else if` block. */\nconst ELSE_IF_PATTERN = /^if\\s/;\n\n/** Pattern used to identify a `let` parameter. */\nconst FOR_LOOP_LET_PATTERN = /^let\\s+(.*)/;\n\n/** Names of variables that are allowed to be used in the `let` expression of a `for` loop. */\nconst ALLOWED_FOR_LOOP_LET_VARIABLES =\n    new Set(['$index', '$first', '$last', '$even', '$odd', '$count']);\n\n/** Creates an `if` loop block from an HTML AST node. */\nexport function createIfBlock(\n    ast: html.BlockGroup, visitor: html.Visitor,\n    bindingParser: BindingParser): {node: t.IfBlock|null, errors: ParseError[]} {\n  const errors: ParseError[] = validateIfBlock(ast);\n  const branches: t.IfBlockBranch[] = [];\n\n  if (errors.length > 0) {\n    return {node: null, errors};\n  }\n\n  // Assumes that the structure is valid since we validated it above.\n  for (const block of ast.blocks) {\n    const children = html.visitAll(visitor, block.children);\n\n    // `{:else}` block.\n    if (block.name === 'else' && block.parameters.length === 0) {\n      branches.push(\n          new t.IfBlockBranch(null, children, null, block.sourceSpan, block.startSourceSpan));\n      continue;\n    }\n\n    const params = parseConditionalBlockParameters(block, errors, bindingParser);\n\n    if (params !== null) {\n      branches.push(new t.IfBlockBranch(\n          params.expression, children, params.expressionAlias, block.sourceSpan,\n          block.startSourceSpan));\n    }\n  }\n\n  return {\n    node: new t.IfBlock(branches, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan),\n    errors,\n  };\n}\n\n/** Creates a `for` loop block from an HTML AST node. */\nexport function createForLoop(\n    ast: html.BlockGroup, visitor: html.Visitor,\n    bindingParser: BindingParser): {node: t.ForLoopBlock|null, errors: ParseError[]} {\n  const [primaryBlock, ...secondaryBlocks] = ast.blocks;\n  const errors: ParseError[] = [];\n  const params = parseForLoopParameters(primaryBlock, errors, bindingParser);\n  let node: t.ForLoopBlock|null = null;\n  let empty: t.ForLoopBlockEmpty|null = null;\n\n  for (const block of secondaryBlocks) {\n    if (block.name === 'empty') {\n      if (empty !== null) {\n        errors.push(new ParseError(block.sourceSpan, 'For loop can only have one \"empty\" block'));\n      } else if (block.parameters.length > 0) {\n        errors.push(new ParseError(block.sourceSpan, 'Empty block cannot have parameters'));\n      } else {\n        empty = new t.ForLoopBlockEmpty(\n            html.visitAll(visitor, block.children), block.sourceSpan, block.startSourceSpan);\n      }\n    } else {\n      errors.push(new ParseError(block.sourceSpan, `Unrecognized loop block \"${block.name}\"`));\n    }\n  }\n\n  if (params !== null) {\n    if (params.trackBy === null) {\n      errors.push(new ParseError(ast.sourceSpan, 'For loop must have a \"track\" expression'));\n    } else {\n      node = new t.ForLoopBlock(\n          params.itemName, params.expression, params.trackBy, params.context,\n          html.visitAll(visitor, primaryBlock.children), empty, ast.sourceSpan, ast.startSourceSpan,\n          ast.endSourceSpan);\n    }\n  }\n\n  return {node, errors};\n}\n\n/** Creates a switch block from an HTML AST node. */\nexport function createSwitchBlock(\n    ast: html.BlockGroup, visitor: html.Visitor,\n    bindingParser: BindingParser): {node: t.SwitchBlock|null, errors: ParseError[]} {\n  const [primaryBlock, ...secondaryBlocks] = ast.blocks;\n  const errors = validateSwitchBlock(ast);\n\n  if (errors.length > 0) {\n    return {node: null, errors};\n  }\n\n  const primaryExpression = parseBlockParameterToBinding(primaryBlock.parameters[0], bindingParser);\n  const cases: t.SwitchBlockCase[] = [];\n  let defaultCase: t.SwitchBlockCase|null = null;\n\n  // Here we assume that all the blocks are valid given that we validated them above.\n  for (const block of secondaryBlocks) {\n    const expression = block.name === 'case' ?\n        parseBlockParameterToBinding(block.parameters[0], bindingParser) :\n        null;\n    const ast = new t.SwitchBlockCase(\n        expression, html.visitAll(visitor, block.children), block.sourceSpan,\n        block.startSourceSpan);\n\n    if (expression === null) {\n      defaultCase = ast;\n    } else {\n      cases.push(ast);\n    }\n  }\n\n  // Ensure that the default case is last in the array.\n  if (defaultCase !== null) {\n    cases.push(defaultCase);\n  }\n\n  return {\n    node: new t.SwitchBlock(\n        primaryExpression, cases, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan),\n    errors\n  };\n}\n\n/** Parses the parameters of a `for` loop block. */\nfunction parseForLoopParameters(\n    block: html.Block, errors: ParseError[], bindingParser: BindingParser) {\n  if (block.parameters.length === 0) {\n    errors.push(new ParseError(block.sourceSpan, 'For loop does not have an expression'));\n    return null;\n  }\n\n  const [expressionParam, ...secondaryParams] = block.parameters;\n  const match =\n      stripOptionalParentheses(expressionParam, errors)?.match(FOR_LOOP_EXPRESSION_PATTERN);\n\n  if (!match || match[2].trim().length === 0) {\n    errors.push(new ParseError(\n        expressionParam.sourceSpan,\n        'Cannot parse expression. For loop expression must match the pattern \"<identifier> of <expression>\"'));\n    return null;\n  }\n\n  const [, itemName, rawExpression] = match;\n  const result = {\n    itemName,\n    trackBy: null as ASTWithSource | null,\n    expression: parseBlockParameterToBinding(expressionParam, bindingParser, rawExpression),\n    context: null as t.ForLoopBlockContext | null,\n  };\n\n  for (const param of secondaryParams) {\n    const letMatch = param.expression.match(FOR_LOOP_LET_PATTERN);\n\n    if (letMatch !== null) {\n      result.context = result.context || {};\n      parseLetParameter(param.sourceSpan, letMatch[1], result.context, errors);\n      continue;\n    }\n\n    const trackMatch = param.expression.match(FOR_LOOP_TRACK_PATTERN);\n\n    if (trackMatch !== null) {\n      if (result.trackBy !== null) {\n        errors.push(\n            new ParseError(param.sourceSpan, 'For loop can only have one \"track\" expression'));\n      } else {\n        result.trackBy = parseBlockParameterToBinding(param, bindingParser, trackMatch[1]);\n      }\n      continue;\n    }\n\n    errors.push(\n        new ParseError(param.sourceSpan, `Unrecognized loop paramater \"${param.expression}\"`));\n  }\n\n  return result;\n}\n\n/** Parses the `let` parameter of a `for` loop block. */\nfunction parseLetParameter(\n    sourceSpan: ParseSourceSpan, expression: string, context: t.ForLoopBlockContext,\n    errors: ParseError[]): void {\n  const parts = expression.split(',');\n\n  for (const part of parts) {\n    const expressionParts = part.split('=');\n    const name = expressionParts.length === 2 ? expressionParts[0].trim() : '';\n    const variableName = expressionParts.length === 2 ? expressionParts[1].trim() : '';\n\n    if (name.length === 0 || variableName.length === 0) {\n      errors.push(new ParseError(\n          sourceSpan,\n          `Invalid for loop \"let\" parameter. Parameter should match the pattern \"<name> = <variable name>\"`));\n    } else if (!ALLOWED_FOR_LOOP_LET_VARIABLES.has(variableName)) {\n      errors.push(new ParseError(\n          sourceSpan,\n          `Unknown \"let\" parameter variable \"${variableName}\". The allowed variables are: ${\n              Array.from(ALLOWED_FOR_LOOP_LET_VARIABLES).join(', ')}`));\n    } else if (context.hasOwnProperty(variableName)) {\n      errors.push(\n          new ParseError(sourceSpan, `Duplicate \"let\" parameter variable \"${variableName}\"`));\n    } else {\n      context[variableName as keyof t.ForLoopBlockContext] = name;\n    }\n  }\n}\n\n/** Checks that the shape of a `if` block is valid. Returns an array of errors. */\nfunction validateIfBlock(ast: html.BlockGroup): ParseError[] {\n  const errors: ParseError[] = [];\n  let hasElse = false;\n\n  for (let i = 0; i < ast.blocks.length; i++) {\n    const block = ast.blocks[i];\n\n    // Conditional blocks only allow `if`, `else if` and `else` blocks.\n    if ((block.name !== 'if' || i > 0) && block.name !== 'else') {\n      errors.push(\n          new ParseError(block.sourceSpan, `Unrecognized conditional block \"${block.name}\"`));\n      continue;\n    }\n\n    if (block.name === 'if') {\n      continue;\n    }\n\n    if (block.parameters.length === 0) {\n      if (hasElse) {\n        errors.push(new ParseError(block.sourceSpan, 'Conditional can only have one \"else\" block'));\n      } else if (ast.blocks.length > 1 && i < ast.blocks.length - 1) {\n        errors.push(\n            new ParseError(block.sourceSpan, 'Else block must be last inside the conditional'));\n      }\n      hasElse = true;\n\n      // `else if` is an edge case, because it has a space after the block name\n      // which means that the `if` is captured as a part of the parameters.\n    } else if (\n        block.parameters.length > 0 && !ELSE_IF_PATTERN.test(block.parameters[0].expression)) {\n      errors.push(new ParseError(block.sourceSpan, 'Else block cannot have parameters'));\n    }\n  }\n\n  return errors;\n}\n\n/** Checks that the shape of a `switch` block is valid. Returns an array of errors. */\nfunction validateSwitchBlock(ast: html.BlockGroup): ParseError[] {\n  const [primaryBlock, ...secondaryBlocks] = ast.blocks;\n  const errors: ParseError[] = [];\n  let hasDefault = false;\n\n  if (primaryBlock.children.length > 0) {\n    errors.push(new ParseError(\n        primaryBlock.sourceSpan, 'Switch block can only contain \"case\" and \"default\" blocks'));\n  }\n\n  if (primaryBlock.parameters.length !== 1) {\n    errors.push(\n        new ParseError(primaryBlock.sourceSpan, 'Switch block must have exactly one parameter'));\n  }\n\n  for (const block of secondaryBlocks) {\n    if (block.name === 'case') {\n      if (block.parameters.length !== 1) {\n        errors.push(new ParseError(block.sourceSpan, 'Case block must have exactly one parameter'));\n      }\n    } else if (block.name === 'default') {\n      if (hasDefault) {\n        errors.push(\n            new ParseError(block.sourceSpan, 'Switch block can only have one \"default\" block'));\n      } else if (block.parameters.length > 0) {\n        errors.push(new ParseError(block.sourceSpan, 'Default block cannot have parameters'));\n      }\n      hasDefault = true;\n    } else {\n      errors.push(new ParseError(\n          block.sourceSpan, 'Switch block can only contain \"case\" and \"default\" blocks'));\n    }\n  }\n\n  return errors;\n}\n\n/**\n * Parses a block parameter into a binding AST.\n * @param ast Block parameter that should be parsed.\n * @param bindingParser Parser that the expression should be parsed with.\n * @param start Index from which to start the parsing. Defaults to 0.\n */\nfunction parseBlockParameterToBinding(\n    ast: html.BlockParameter, bindingParser: BindingParser, start?: number): ASTWithSource;\n\n/**\n * Parses a block parameter into a binding AST.\n * @param ast Block parameter that should be parsed.\n * @param bindingParser Parser that the expression should be parsed with.\n * @param part Specific part of the expression that should be parsed.\n */\nfunction parseBlockParameterToBinding(\n    ast: html.BlockParameter, bindingParser: BindingParser, part: string): ASTWithSource;\n\nfunction parseBlockParameterToBinding(\n    ast: html.BlockParameter, bindingParser: BindingParser,\n    part: string|number = 0): ASTWithSource {\n  let start: number;\n  let end: number;\n\n  if (typeof part === 'number') {\n    start = part;\n    end = ast.expression.length;\n  } else {\n    // Note: `lastIndexOf` here should be enough to know the start index of the expression,\n    // because we know that it'll be at the end of the param. Ideally we could use the `d`\n    // flag when matching via regex and get the index from `match.indices`, but it's unclear\n    // if we can use it yet since it's a relatively new feature. See:\n    // https://github.com/tc39/proposal-regexp-match-indices\n    start = Math.max(0, ast.expression.lastIndexOf(part));\n    end = start + part.length;\n  }\n\n  return bindingParser.parseBinding(\n      ast.expression.slice(start, end), false, ast.sourceSpan, ast.sourceSpan.start.offset + start);\n}\n\n/** Parses the parameter of a conditional block (`if` or `else if`). */\nfunction parseConditionalBlockParameters(\n    block: html.Block, errors: ParseError[], bindingParser: BindingParser) {\n  if (block.parameters.length === 0) {\n    errors.push(new ParseError(block.sourceSpan, 'Conditional block does not have an expression'));\n    return null;\n  }\n\n  const isPrimaryIfBlock = block.name === 'if';\n  const expression =\n      // Expressions for `{:else if}` blocks start at 2 to skip the `if` from the expression.\n      parseBlockParameterToBinding(block.parameters[0], bindingParser, isPrimaryIfBlock ? 0 : 2);\n  let expressionAlias: string|null = null;\n\n  // Start from 1 since we processed the first parameter already.\n  for (let i = 1; i < block.parameters.length; i++) {\n    const param = block.parameters[i];\n    const aliasMatch = param.expression.match(CONDITIONAL_ALIAS_PATTERN);\n\n    // For now conditionals can only have an `as` parameter.\n    // We may want to rework this later if we add more.\n    if (aliasMatch === null) {\n      errors.push(new ParseError(\n          param.sourceSpan, `Unrecognized conditional paramater \"${param.expression}\"`));\n    } else if (!isPrimaryIfBlock) {\n      errors.push(new ParseError(\n          param.sourceSpan, '\"as\" expression is only allowed on the primary \"if\" block'));\n    } else if (expressionAlias !== null) {\n      errors.push(\n          new ParseError(param.sourceSpan, 'Conditional can only have one \"as\" expression'));\n    } else {\n      expressionAlias = aliasMatch[1].trim();\n    }\n  }\n\n  return {expression, expressionAlias};\n}\n\n/** Strips optional parentheses around from a control from expression parameter. */\nfunction stripOptionalParentheses(param: html.BlockParameter, errors: ParseError[]): string|null {\n  const expression = param.expression;\n  const spaceRegex = /^\\s$/;\n  let openParens = 0;\n  let start = 0;\n  let end = expression.length - 1;\n\n  for (let i = 0; i < expression.length; i++) {\n    const char = expression[i];\n\n    if (char === '(') {\n      start = i + 1;\n      openParens++;\n    } else if (spaceRegex.test(char)) {\n      continue;\n    } else {\n      break;\n    }\n  }\n\n  if (openParens === 0) {\n    return expression;\n  }\n\n  for (let i = expression.length - 1; i > -1; i--) {\n    const char = expression[i];\n\n    if (char === ')') {\n      end = i;\n      openParens--;\n      if (openParens === 0) {\n        break;\n      }\n    } else if (spaceRegex.test(char)) {\n      continue;\n    } else {\n      break;\n    }\n  }\n\n  if (openParens !== 0) {\n    errors.push(new ParseError(param.sourceSpan, 'Unclosed parentheses in expression'));\n    return null;\n  }\n\n  return expression.slice(start, end);\n}\n"]}

package/esm2022/src/render3/r3_deferred_blocks.mjs

@@ -85,6 +85,9 @@ function parsePlaceholderBlock(ast, visitor) {
     let minimumTime = null;
     for (const param of ast.parameters) {
         if (MINIMUM_PARAMETER_PATTERN.test(param.expression)) {
+            if (minimumTime != null) {
+                throw new Error(`Placeholder block can only have one "minimum" parameter`);
+            }
             const parsedTime = parseDeferredTime(param.expression.slice(getTriggerParametersStart(param.expression)));
             if (parsedTime === null) {
                 throw new Error(`Could not parse time value of parameter "minimum"`);
@@ -102,6 +105,9 @@ function parseLoadingBlock(ast, visitor) {
     let minimumTime = null;
     for (const param of ast.parameters) {
         if (AFTER_PARAMETER_PATTERN.test(param.expression)) {
+            if (afterTime != null) {
+                throw new Error(`Loading block can only have one "after" parameter`);
+            }
             const parsedTime = parseDeferredTime(param.expression.slice(getTriggerParametersStart(param.expression)));
             if (parsedTime === null) {
                 throw new Error(`Could not parse time value of parameter "after"`);
@@ -109,6 +115,9 @@ function parseLoadingBlock(ast, visitor) {
             afterTime = parsedTime;
         }
         else if (MINIMUM_PARAMETER_PATTERN.test(param.expression)) {
+            if (minimumTime != null) {
+                throw new Error(`Loading block can only have one "minimum" parameter`);
+            }
             const parsedTime = parseDeferredTime(param.expression.slice(getTriggerParametersStart(param.expression)));
             if (parsedTime === null) {
                 throw new Error(`Could not parse time value of parameter "minimum"`);
@@ -128,24 +137,22 @@ function parseErrorBlock(ast, visitor) {
     return new t.DeferredBlockError(html.visitAll(visitor, ast.children), ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan);
 }
 function parsePrimaryTriggers(params, bindingParser, errors) {
-    const triggers = [];
-    const prefetchTriggers = [];
+    const triggers = {};
+    const prefetchTriggers = {};
     for (const param of params) {
         // The lexer ignores the leading spaces so we can assume
         // that the expression starts with a keyword.
         if (WHEN_PARAMETER_PATTERN.test(param.expression)) {
-            const result = parseWhenTrigger(param, bindingParser, errors);
-            result !== null && triggers.push(result);
+            parseWhenTrigger(param, bindingParser, triggers, errors);
         }
         else if (ON_PARAMETER_PATTERN.test(param.expression)) {
-            triggers.push(...parseOnTrigger(param, errors));
+            parseOnTrigger(param, triggers, errors);
         }
         else if (PREFETCH_WHEN_PATTERN.test(param.expression)) {
-            const result = parseWhenTrigger(param, bindingParser, errors);
-            result !== null && prefetchTriggers.push(result);
+            parseWhenTrigger(param, bindingParser, prefetchTriggers, errors);
         }
         else if (PREFETCH_ON_PATTERN.test(param.expression)) {
-            prefetchTriggers.push(...parseOnTrigger(param, errors));
+            parseOnTrigger(param, prefetchTriggers, errors);
         }
         else {
             errors.push(new ParseError(param.sourceSpan, 'Unrecognized trigger'));
@@ -153,4 +160,4 @@ function parsePrimaryTriggers(params, bindingParser, errors) {
     }
     return { triggers, prefetchTriggers };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"r3_deferred_blocks.js","sourceRoot":"","sources":["../../../../../../../packages/compiler/src/render3/r3_deferred_blocks.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport * as html from '../ml_parser/ast';\nimport {ParseError} from '../parse_util';\nimport {BindingParser} from '../template_parser/binding_parser';\n\nimport * as t from './r3_ast';\nimport {getTriggerParametersStart, parseDeferredTime, parseOnTrigger, parseWhenTrigger} from './r3_deferred_triggers';\n\n/** Pattern to identify a `prefetch when` trigger. */\nconst PREFETCH_WHEN_PATTERN = /^prefetch\\s+when\\s/;\n\n/** Pattern to identify a `prefetch on` trigger. */\nconst PREFETCH_ON_PATTERN = /^prefetch\\s+on\\s/;\n\n/** Pattern to identify a `minimum` parameter in a block. */\nconst MINIMUM_PARAMETER_PATTERN = /^minimum\\s/;\n\n/** Pattern to identify a `after` parameter in a block. */\nconst AFTER_PARAMETER_PATTERN = /^after\\s/;\n\n/** Pattern to identify a `when` parameter in a block. */\nconst WHEN_PARAMETER_PATTERN = /^when\\s/;\n\n/** Pattern to identify a `on` parameter in a block. */\nconst ON_PARAMETER_PATTERN = /^on\\s/;\n\n/** Possible types of secondary deferred blocks. */\nexport enum SecondaryDeferredBlockType {\n  PLACEHOLDER = 'placeholder',\n  LOADING = 'loading',\n  ERROR = 'error',\n}\n\n/** Creates a deferred block from an HTML AST node. */\nexport function createDeferredBlock(\n    ast: html.BlockGroup, visitor: html.Visitor,\n    bindingParser: BindingParser): {node: t.DeferredBlock, errors: ParseError[]} {\n  const errors: ParseError[] = [];\n  const [primaryBlock, ...secondaryBlocks] = ast.blocks;\n  const {triggers, prefetchTriggers} =\n      parsePrimaryTriggers(primaryBlock.parameters, bindingParser, errors);\n  const {placeholder, loading, error} = parseSecondaryBlocks(secondaryBlocks, errors, visitor);\n\n  return {\n    node: new t.DeferredBlock(\n        html.visitAll(visitor, primaryBlock.children), triggers, prefetchTriggers, placeholder,\n        loading, error, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan),\n    errors,\n  };\n}\n\nfunction parseSecondaryBlocks(blocks: html.Block[], errors: ParseError[], visitor: html.Visitor) {\n  let placeholder: t.DeferredBlockPlaceholder|null = null;\n  let loading: t.DeferredBlockLoading|null = null;\n  let error: t.DeferredBlockError|null = null;\n\n  for (const block of blocks) {\n    try {\n      switch (block.name) {\n        case SecondaryDeferredBlockType.PLACEHOLDER:\n          if (placeholder !== null) {\n            errors.push(new ParseError(\n                block.startSourceSpan,\n                `\"defer\" block can only have one \"${\n                    SecondaryDeferredBlockType.PLACEHOLDER}\" block`));\n          } else {\n            placeholder = parsePlaceholderBlock(block, visitor);\n          }\n          break;\n\n        case SecondaryDeferredBlockType.LOADING:\n          if (loading !== null) {\n            errors.push(new ParseError(\n                block.startSourceSpan,\n                `\"defer\" block can only have one \"${SecondaryDeferredBlockType.LOADING}\" block`));\n          } else {\n            loading = parseLoadingBlock(block, visitor);\n          }\n          break;\n\n        case SecondaryDeferredBlockType.ERROR:\n          if (error !== null) {\n            errors.push(new ParseError(\n                block.startSourceSpan,\n                `\"defer\" block can only have one \"${SecondaryDeferredBlockType.ERROR}\" block`));\n          } else {\n            error = parseErrorBlock(block, visitor);\n          }\n          break;\n\n        default:\n          errors.push(new ParseError(block.startSourceSpan, `Unrecognized block \"${block.name}\"`));\n          break;\n      }\n    } catch (e) {\n      errors.push(new ParseError(block.startSourceSpan, (e as Error).message));\n    }\n  }\n\n  return {placeholder, loading, error};\n}\n\nfunction parsePlaceholderBlock(ast: html.Block, visitor: html.Visitor): t.DeferredBlockPlaceholder {\n  let minimumTime: number|null = null;\n\n  for (const param of ast.parameters) {\n    if (MINIMUM_PARAMETER_PATTERN.test(param.expression)) {\n      const parsedTime =\n          parseDeferredTime(param.expression.slice(getTriggerParametersStart(param.expression)));\n\n      if (parsedTime === null) {\n        throw new Error(`Could not parse time value of parameter \"minimum\"`);\n      }\n\n      minimumTime = parsedTime;\n    } else {\n      throw new Error(`Unrecognized parameter in \"${\n          SecondaryDeferredBlockType.PLACEHOLDER}\" block: \"${param.expression}\"`);\n    }\n  }\n\n  return new t.DeferredBlockPlaceholder(\n      html.visitAll(visitor, ast.children), minimumTime, ast.sourceSpan, ast.startSourceSpan,\n      ast.endSourceSpan);\n}\n\nfunction parseLoadingBlock(ast: html.Block, visitor: html.Visitor): t.DeferredBlockLoading {\n  let afterTime: number|null = null;\n  let minimumTime: number|null = null;\n\n  for (const param of ast.parameters) {\n    if (AFTER_PARAMETER_PATTERN.test(param.expression)) {\n      const parsedTime =\n          parseDeferredTime(param.expression.slice(getTriggerParametersStart(param.expression)));\n\n      if (parsedTime === null) {\n        throw new Error(`Could not parse time value of parameter \"after\"`);\n      }\n\n      afterTime = parsedTime;\n    } else if (MINIMUM_PARAMETER_PATTERN.test(param.expression)) {\n      const parsedTime =\n          parseDeferredTime(param.expression.slice(getTriggerParametersStart(param.expression)));\n\n      if (parsedTime === null) {\n        throw new Error(`Could not parse time value of parameter \"minimum\"`);\n      }\n\n      minimumTime = parsedTime;\n    } else {\n      throw new Error(`Unrecognized parameter in \"${SecondaryDeferredBlockType.LOADING}\" block: \"${\n          param.expression}\"`);\n    }\n  }\n\n  return new t.DeferredBlockLoading(\n      html.visitAll(visitor, ast.children), afterTime, minimumTime, ast.sourceSpan,\n      ast.startSourceSpan, ast.endSourceSpan);\n}\n\n\nfunction parseErrorBlock(ast: html.Block, visitor: html.Visitor): t.DeferredBlockError {\n  if (ast.parameters.length > 0) {\n    throw new Error(`\"${SecondaryDeferredBlockType.ERROR}\" block cannot have parameters`);\n  }\n\n  return new t.DeferredBlockError(\n      html.visitAll(visitor, ast.children), ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan);\n}\n\nfunction parsePrimaryTriggers(\n    params: html.BlockParameter[], bindingParser: BindingParser, errors: ParseError[]) {\n  const triggers: t.DeferredTrigger[] = [];\n  const prefetchTriggers: t.DeferredTrigger[] = [];\n\n  for (const param of params) {\n    // The lexer ignores the leading spaces so we can assume\n    // that the expression starts with a keyword.\n    if (WHEN_PARAMETER_PATTERN.test(param.expression)) {\n      const result = parseWhenTrigger(param, bindingParser, errors);\n      result !== null && triggers.push(result);\n    } else if (ON_PARAMETER_PATTERN.test(param.expression)) {\n      triggers.push(...parseOnTrigger(param, errors));\n    } else if (PREFETCH_WHEN_PATTERN.test(param.expression)) {\n      const result = parseWhenTrigger(param, bindingParser, errors);\n      result !== null && prefetchTriggers.push(result);\n    } else if (PREFETCH_ON_PATTERN.test(param.expression)) {\n      prefetchTriggers.push(...parseOnTrigger(param, errors));\n    } else {\n      errors.push(new ParseError(param.sourceSpan, 'Unrecognized trigger'));\n    }\n  }\n\n  return {triggers, prefetchTriggers};\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"r3_deferred_blocks.js","sourceRoot":"","sources":["../../../../../../../packages/compiler/src/render3/r3_deferred_blocks.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport * as html from '../ml_parser/ast';\nimport {ParseError} from '../parse_util';\nimport {BindingParser} from '../template_parser/binding_parser';\n\nimport * as t from './r3_ast';\nimport {getTriggerParametersStart, parseDeferredTime, parseOnTrigger, parseWhenTrigger} from './r3_deferred_triggers';\n\n/** Pattern to identify a `prefetch when` trigger. */\nconst PREFETCH_WHEN_PATTERN = /^prefetch\\s+when\\s/;\n\n/** Pattern to identify a `prefetch on` trigger. */\nconst PREFETCH_ON_PATTERN = /^prefetch\\s+on\\s/;\n\n/** Pattern to identify a `minimum` parameter in a block. */\nconst MINIMUM_PARAMETER_PATTERN = /^minimum\\s/;\n\n/** Pattern to identify a `after` parameter in a block. */\nconst AFTER_PARAMETER_PATTERN = /^after\\s/;\n\n/** Pattern to identify a `when` parameter in a block. */\nconst WHEN_PARAMETER_PATTERN = /^when\\s/;\n\n/** Pattern to identify a `on` parameter in a block. */\nconst ON_PARAMETER_PATTERN = /^on\\s/;\n\n/** Possible types of secondary deferred blocks. */\nexport enum SecondaryDeferredBlockType {\n  PLACEHOLDER = 'placeholder',\n  LOADING = 'loading',\n  ERROR = 'error',\n}\n\n/** Creates a deferred block from an HTML AST node. */\nexport function createDeferredBlock(\n    ast: html.BlockGroup, visitor: html.Visitor,\n    bindingParser: BindingParser): {node: t.DeferredBlock, errors: ParseError[]} {\n  const errors: ParseError[] = [];\n  const [primaryBlock, ...secondaryBlocks] = ast.blocks;\n  const {triggers, prefetchTriggers} =\n      parsePrimaryTriggers(primaryBlock.parameters, bindingParser, errors);\n  const {placeholder, loading, error} = parseSecondaryBlocks(secondaryBlocks, errors, visitor);\n\n  return {\n    node: new t.DeferredBlock(\n        html.visitAll(visitor, primaryBlock.children), triggers, prefetchTriggers, placeholder,\n        loading, error, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan),\n    errors,\n  };\n}\n\nfunction parseSecondaryBlocks(blocks: html.Block[], errors: ParseError[], visitor: html.Visitor) {\n  let placeholder: t.DeferredBlockPlaceholder|null = null;\n  let loading: t.DeferredBlockLoading|null = null;\n  let error: t.DeferredBlockError|null = null;\n\n  for (const block of blocks) {\n    try {\n      switch (block.name) {\n        case SecondaryDeferredBlockType.PLACEHOLDER:\n          if (placeholder !== null) {\n            errors.push(new ParseError(\n                block.startSourceSpan,\n                `\"defer\" block can only have one \"${\n                    SecondaryDeferredBlockType.PLACEHOLDER}\" block`));\n          } else {\n            placeholder = parsePlaceholderBlock(block, visitor);\n          }\n          break;\n\n        case SecondaryDeferredBlockType.LOADING:\n          if (loading !== null) {\n            errors.push(new ParseError(\n                block.startSourceSpan,\n                `\"defer\" block can only have one \"${SecondaryDeferredBlockType.LOADING}\" block`));\n          } else {\n            loading = parseLoadingBlock(block, visitor);\n          }\n          break;\n\n        case SecondaryDeferredBlockType.ERROR:\n          if (error !== null) {\n            errors.push(new ParseError(\n                block.startSourceSpan,\n                `\"defer\" block can only have one \"${SecondaryDeferredBlockType.ERROR}\" block`));\n          } else {\n            error = parseErrorBlock(block, visitor);\n          }\n          break;\n\n        default:\n          errors.push(new ParseError(block.startSourceSpan, `Unrecognized block \"${block.name}\"`));\n          break;\n      }\n    } catch (e) {\n      errors.push(new ParseError(block.startSourceSpan, (e as Error).message));\n    }\n  }\n\n  return {placeholder, loading, error};\n}\n\nfunction parsePlaceholderBlock(ast: html.Block, visitor: html.Visitor): t.DeferredBlockPlaceholder {\n  let minimumTime: number|null = null;\n\n  for (const param of ast.parameters) {\n    if (MINIMUM_PARAMETER_PATTERN.test(param.expression)) {\n      if (minimumTime != null) {\n        throw new Error(`Placeholder block can only have one \"minimum\" parameter`);\n      }\n\n      const parsedTime =\n          parseDeferredTime(param.expression.slice(getTriggerParametersStart(param.expression)));\n\n      if (parsedTime === null) {\n        throw new Error(`Could not parse time value of parameter \"minimum\"`);\n      }\n\n      minimumTime = parsedTime;\n    } else {\n      throw new Error(`Unrecognized parameter in \"${\n          SecondaryDeferredBlockType.PLACEHOLDER}\" block: \"${param.expression}\"`);\n    }\n  }\n\n  return new t.DeferredBlockPlaceholder(\n      html.visitAll(visitor, ast.children), minimumTime, ast.sourceSpan, ast.startSourceSpan,\n      ast.endSourceSpan);\n}\n\nfunction parseLoadingBlock(ast: html.Block, visitor: html.Visitor): t.DeferredBlockLoading {\n  let afterTime: number|null = null;\n  let minimumTime: number|null = null;\n\n  for (const param of ast.parameters) {\n    if (AFTER_PARAMETER_PATTERN.test(param.expression)) {\n      if (afterTime != null) {\n        throw new Error(`Loading block can only have one \"after\" parameter`);\n      }\n\n      const parsedTime =\n          parseDeferredTime(param.expression.slice(getTriggerParametersStart(param.expression)));\n\n      if (parsedTime === null) {\n        throw new Error(`Could not parse time value of parameter \"after\"`);\n      }\n\n      afterTime = parsedTime;\n    } else if (MINIMUM_PARAMETER_PATTERN.test(param.expression)) {\n      if (minimumTime != null) {\n        throw new Error(`Loading block can only have one \"minimum\" parameter`);\n      }\n\n      const parsedTime =\n          parseDeferredTime(param.expression.slice(getTriggerParametersStart(param.expression)));\n\n      if (parsedTime === null) {\n        throw new Error(`Could not parse time value of parameter \"minimum\"`);\n      }\n\n      minimumTime = parsedTime;\n    } else {\n      throw new Error(`Unrecognized parameter in \"${SecondaryDeferredBlockType.LOADING}\" block: \"${\n          param.expression}\"`);\n    }\n  }\n\n  return new t.DeferredBlockLoading(\n      html.visitAll(visitor, ast.children), afterTime, minimumTime, ast.sourceSpan,\n      ast.startSourceSpan, ast.endSourceSpan);\n}\n\n\nfunction parseErrorBlock(ast: html.Block, visitor: html.Visitor): t.DeferredBlockError {\n  if (ast.parameters.length > 0) {\n    throw new Error(`\"${SecondaryDeferredBlockType.ERROR}\" block cannot have parameters`);\n  }\n\n  return new t.DeferredBlockError(\n      html.visitAll(visitor, ast.children), ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan);\n}\n\nfunction parsePrimaryTriggers(\n    params: html.BlockParameter[], bindingParser: BindingParser, errors: ParseError[]) {\n  const triggers: t.DeferredBlockTriggers = {};\n  const prefetchTriggers: t.DeferredBlockTriggers = {};\n\n  for (const param of params) {\n    // The lexer ignores the leading spaces so we can assume\n    // that the expression starts with a keyword.\n    if (WHEN_PARAMETER_PATTERN.test(param.expression)) {\n      parseWhenTrigger(param, bindingParser, triggers, errors);\n    } else if (ON_PARAMETER_PATTERN.test(param.expression)) {\n      parseOnTrigger(param, triggers, errors);\n    } else if (PREFETCH_WHEN_PATTERN.test(param.expression)) {\n      parseWhenTrigger(param, bindingParser, prefetchTriggers, errors);\n    } else if (PREFETCH_ON_PATTERN.test(param.expression)) {\n      parseOnTrigger(param, prefetchTriggers, errors);\n    } else {\n      errors.push(new ParseError(param.sourceSpan, 'Unrecognized trigger'));\n    }\n  }\n\n  return {triggers, prefetchTriggers};\n}\n"]}