@angular/compiler 17.0.0-rc.2 → 17.0.0

package/esm2022/src/template/pipeline/src/phases/defer_resolve_targets.mjs

@@ -47,6 +47,26 @@ export function resolveDeferTargetNames(job) {
             case ir.DeferTriggerKind.Interaction:
             case ir.DeferTriggerKind.Viewport:
                 if (op.trigger.targetName === null) {
+                    // A `null` target name indicates we should default to the first element in the
+                    // placeholder block.
+                    if (placeholderView === null) {
+                        throw new Error('defer on trigger with no target name must have a placeholder block');
+                    }
+                    const placeholder = job.views.get(placeholderView);
+                    if (placeholder == undefined) {
+                        throw new Error('AssertionError: could not find placeholder view for defer on trigger');
+                    }
+                    for (const placeholderOp of placeholder.create) {
+                        if (ir.hasConsumesSlotTrait(placeholderOp) &&
+                            (ir.isElementOrContainerOp(placeholderOp) ||
+                                placeholderOp.kind === ir.OpKind.Projection)) {
+                            op.trigger.targetXref = placeholderOp.xref;
+                            op.trigger.targetView = placeholderView;
+                            op.trigger.targetSlotViewSteps = -1;
+                            op.trigger.targetSlot = placeholderOp.handle;
+                            return;
+                        }
+                    }
                     return;
                 }
                 let view = placeholderView !== null ? job.views.get(placeholderView) : deferOwnerView;
@@ -90,4 +110,4 @@ class Scope {
         this.targets = new Map();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"defer_resolve_targets.js","sourceRoot":"","sources":["../../../../../../../../../../packages/compiler/src/template/pipeline/src/phases/defer_resolve_targets.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,MAAM,UAAU,CAAC;AAG/B;;;;;GAKG;AACH,MAAM,UAAU,uBAAuB,CAAC,GAA4B;IAClE,MAAM,MAAM,GAAG,IAAI,GAAG,EAAoB,CAAC;IAE3C,SAAS,eAAe,CAAC,IAAyB;QAChD,IAAI,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;YACzB,OAAO,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAE,CAAC;SAC/B;QAED,MAAM,KAAK,GAAG,IAAI,KAAK,EAAE,CAAC;QAC1B,KAAK,MAAM,EAAE,IAAI,IAAI,CAAC,MAAM,EAAE;YAC5B,yCAAyC;YACzC,IAAI,CAAC,EAAE,CAAC,sBAAsB,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,SAAS,KAAK,IAAI,EAAE;gBAC3D,SAAS;aACV;YACD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE;gBAChC,MAAM,IAAI,KAAK,CACX,6EAA6E,CAAC,CAAC;aACpF;YAED,KAAK,MAAM,GAAG,IAAI,EAAE,CAAC,SAAS,EAAE;gBAC9B,IAAI,GAAG,CAAC,MAAM,KAAK,EAAE,EAAE;oBACrB,SAAS;iBACV;gBACD,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,EAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,MAAM,EAAC,CAAC,CAAC;aAC/D;SACF;QAED,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC7B,OAAO,KAAK,CAAC;IACf,CAAC;IAED,SAAS,cAAc,CACnB,cAAmC,EAAE,EAAgB,EACrD,eAA+B;QACjC,QAAQ,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE;YACvB,KAAK,EAAE,CAAC,gBAAgB,CAAC,IAAI,CAAC;YAC9B,KAAK,EAAE,CAAC,gBAAgB,CAAC,SAAS,CAAC;YACnC,KAAK,EAAE,CAAC,gBAAgB,CAAC,KAAK;gBAC5B,OAAO;YACT,KAAK,EAAE,CAAC,gBAAgB,CAAC,KAAK,CAAC;YAC/B,KAAK,EAAE,CAAC,gBAAgB,CAAC,WAAW,CAAC;YACrC,KAAK,EAAE,CAAC,gBAAgB,CAAC,QAAQ;gBAC/B,IAAI,EAAE,CAAC,OAAO,CAAC,UAAU,KAAK,IAAI,EAAE;oBAClC,OAAO;iBACR;gBACD,IAAI,IAAI,GACJ,eAAe,KAAK,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,eAAe,CAAE,CAAC,CAAC,CAAC,cAAc,CAAC;gBAChF,IAAI,IAAI,GAAG,eAAe,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAE7C,OAAO,IAAI,KAAK,IAAI,EAAE;oBACpB,MAAM,KAAK,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;oBACpC,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE;wBAC5C,MAAM,EAAC,IAAI,EAAE,IAAI,EAAC,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,OAAO,CAAC,UAAU,CAAE,CAAC;wBAE/D,EAAE,CAAC,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;wBAC7B,EAAE,CAAC,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC;wBAClC,EAAE,CAAC,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;wBACtC,EAAE,CAAC,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;wBAC7B,OAAO;qBACR;oBAED,IAAI,GAAG,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAE,CAAC,CAAC,CAAC,IAAI,CAAC;oBACjE,IAAI,EAAE,CAAC;iBACR;gBACD,MAAM;YACR;gBACE,MAAM,IAAI,KAAK,CAAC,gBAAiB,EAAE,CAAC,OAAe,CAAC,IAAI,cAAc,CAAC,CAAC;SAC3E;IACH,CAAC;IAED,+DAA+D;IAC/D,KAAK,MAAM,IAAI,IAAI,GAAG,CAAC,KAAK,EAAE;QAC5B,MAAM,MAAM,GAAG,IAAI,GAAG,EAAyB,CAAC;QAChD,KAAK,MAAM,EAAE,IAAI,IAAI,CAAC,MAAM,EAAE;YAC5B,QAAQ,EAAE,CAAC,IAAI,EAAE;gBACf,KAAK,EAAE,CAAC,MAAM,CAAC,KAAK;oBAClB,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;oBACxB,MAAM;gBACR,KAAK,EAAE,CAAC,MAAM,CAAC,OAAO;oBACpB,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAE,CAAC;oBACtC,cAAc,CAAC,IAAI,EAAE,EAAE,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;oBAClD,MAAM;aACT;SACF;KACF;AACH,CAAC;AAED,MAAM,KAAK;IAAX;QACE,YAAO,GAAG,IAAI,GAAG,EAAkD,CAAC;IACtE,CAAC;CAAA","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 ir from '../../ir';\nimport type {ViewCompilationUnit, ComponentCompilationJob} from '../compilation';\n\n/**\n * Some `defer` conditions can reference other elements in the template, using their local reference\n * names. However, the semantics are quite different from the normal local reference system: in\n * particular, we need to look at local reference names in enclosing views. This phase resolves\n * all such references to actual xrefs.\n */\nexport function resolveDeferTargetNames(job: ComponentCompilationJob): void {\n  const scopes = new Map<ir.XrefId, Scope>();\n\n  function getScopeForView(view: ViewCompilationUnit): Scope {\n    if (scopes.has(view.xref)) {\n      return scopes.get(view.xref)!;\n    }\n\n    const scope = new Scope();\n    for (const op of view.create) {\n      // add everything that can be referenced.\n      if (!ir.isElementOrContainerOp(op) || op.localRefs === null) {\n        continue;\n      }\n      if (!Array.isArray(op.localRefs)) {\n        throw new Error(\n            'LocalRefs were already processed, but were needed to resolve defer targets.');\n      }\n\n      for (const ref of op.localRefs) {\n        if (ref.target !== '') {\n          continue;\n        }\n        scope.targets.set(ref.name, {xref: op.xref, slot: op.handle});\n      }\n    }\n\n    scopes.set(view.xref, scope);\n    return scope;\n  }\n\n  function resolveTrigger(\n      deferOwnerView: ViewCompilationUnit, op: ir.DeferOnOp,\n      placeholderView: ir.XrefId|null): void {\n    switch (op.trigger.kind) {\n      case ir.DeferTriggerKind.Idle:\n      case ir.DeferTriggerKind.Immediate:\n      case ir.DeferTriggerKind.Timer:\n        return;\n      case ir.DeferTriggerKind.Hover:\n      case ir.DeferTriggerKind.Interaction:\n      case ir.DeferTriggerKind.Viewport:\n        if (op.trigger.targetName === null) {\n          return;\n        }\n        let view: ViewCompilationUnit|null =\n            placeholderView !== null ? job.views.get(placeholderView)! : deferOwnerView;\n        let step = placeholderView !== null ? -1 : 0;\n\n        while (view !== null) {\n          const scope = getScopeForView(view);\n          if (scope.targets.has(op.trigger.targetName)) {\n            const {xref, slot} = scope.targets.get(op.trigger.targetName)!;\n\n            op.trigger.targetXref = xref;\n            op.trigger.targetView = view.xref;\n            op.trigger.targetSlotViewSteps = step;\n            op.trigger.targetSlot = slot;\n            return;\n          }\n\n          view = view.parent !== null ? job.views.get(view.parent)! : null;\n          step++;\n        }\n        break;\n      default:\n        throw new Error(`Trigger kind ${(op.trigger as any).kind} not handled`);\n    }\n  }\n\n  // Find the defer ops, and assign the data about their targets.\n  for (const unit of job.units) {\n    const defers = new Map<ir.XrefId, ir.DeferOp>();\n    for (const op of unit.create) {\n      switch (op.kind) {\n        case ir.OpKind.Defer:\n          defers.set(op.xref, op);\n          break;\n        case ir.OpKind.DeferOn:\n          const deferOp = defers.get(op.defer)!;\n          resolveTrigger(unit, op, deferOp.placeholderView);\n          break;\n      }\n    }\n  }\n}\n\nclass Scope {\n  targets = new Map<string, {xref: ir.XrefId, slot: ir.SlotHandle}>();\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"defer_resolve_targets.js","sourceRoot":"","sources":["../../../../../../../../../../packages/compiler/src/template/pipeline/src/phases/defer_resolve_targets.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 ir from '../../ir';\nimport type {ComponentCompilationJob, ViewCompilationUnit} from '../compilation';\n\n/**\n * Some `defer` conditions can reference other elements in the template, using their local reference\n * names. However, the semantics are quite different from the normal local reference system: in\n * particular, we need to look at local reference names in enclosing views. This phase resolves\n * all such references to actual xrefs.\n */\nexport function resolveDeferTargetNames(job: ComponentCompilationJob): void {\n  const scopes = new Map<ir.XrefId, Scope>();\n\n  function getScopeForView(view: ViewCompilationUnit): Scope {\n    if (scopes.has(view.xref)) {\n      return scopes.get(view.xref)!;\n    }\n\n    const scope = new Scope();\n    for (const op of view.create) {\n      // add everything that can be referenced.\n      if (!ir.isElementOrContainerOp(op) || op.localRefs === null) {\n        continue;\n      }\n      if (!Array.isArray(op.localRefs)) {\n        throw new Error(\n            'LocalRefs were already processed, but were needed to resolve defer targets.');\n      }\n\n      for (const ref of op.localRefs) {\n        if (ref.target !== '') {\n          continue;\n        }\n        scope.targets.set(ref.name, {xref: op.xref, slot: op.handle});\n      }\n    }\n\n    scopes.set(view.xref, scope);\n    return scope;\n  }\n\n  function resolveTrigger(\n      deferOwnerView: ViewCompilationUnit, op: ir.DeferOnOp,\n      placeholderView: ir.XrefId|null): void {\n    switch (op.trigger.kind) {\n      case ir.DeferTriggerKind.Idle:\n      case ir.DeferTriggerKind.Immediate:\n      case ir.DeferTriggerKind.Timer:\n        return;\n      case ir.DeferTriggerKind.Hover:\n      case ir.DeferTriggerKind.Interaction:\n      case ir.DeferTriggerKind.Viewport:\n        if (op.trigger.targetName === null) {\n          // A `null` target name indicates we should default to the first element in the\n          // placeholder block.\n          if (placeholderView === null) {\n            throw new Error('defer on trigger with no target name must have a placeholder block');\n          }\n          const placeholder = job.views.get(placeholderView);\n          if (placeholder == undefined) {\n            throw new Error('AssertionError: could not find placeholder view for defer on trigger');\n          }\n          for (const placeholderOp of placeholder.create) {\n            if (ir.hasConsumesSlotTrait(placeholderOp) &&\n                (ir.isElementOrContainerOp(placeholderOp) ||\n                 placeholderOp.kind === ir.OpKind.Projection)) {\n              op.trigger.targetXref = placeholderOp.xref;\n              op.trigger.targetView = placeholderView;\n              op.trigger.targetSlotViewSteps = -1;\n              op.trigger.targetSlot = placeholderOp.handle;\n              return;\n            }\n          }\n          return;\n        }\n        let view: ViewCompilationUnit|null =\n            placeholderView !== null ? job.views.get(placeholderView)! : deferOwnerView;\n        let step = placeholderView !== null ? -1 : 0;\n\n        while (view !== null) {\n          const scope = getScopeForView(view);\n          if (scope.targets.has(op.trigger.targetName)) {\n            const {xref, slot} = scope.targets.get(op.trigger.targetName)!;\n\n            op.trigger.targetXref = xref;\n            op.trigger.targetView = view.xref;\n            op.trigger.targetSlotViewSteps = step;\n            op.trigger.targetSlot = slot;\n            return;\n          }\n\n          view = view.parent !== null ? job.views.get(view.parent)! : null;\n          step++;\n        }\n        break;\n      default:\n        throw new Error(`Trigger kind ${(op.trigger as any).kind} not handled`);\n    }\n  }\n\n  // Find the defer ops, and assign the data about their targets.\n  for (const unit of job.units) {\n    const defers = new Map<ir.XrefId, ir.DeferOp>();\n    for (const op of unit.create) {\n      switch (op.kind) {\n        case ir.OpKind.Defer:\n          defers.set(op.xref, op);\n          break;\n        case ir.OpKind.DeferOn:\n          const deferOp = defers.get(op.defer)!;\n          resolveTrigger(unit, op, deferOp.placeholderView);\n          break;\n      }\n    }\n  }\n}\n\nclass Scope {\n  targets = new Map<string, {xref: ir.XrefId, slot: ir.SlotHandle}>();\n}\n"]}

package/esm2022/src/template/pipeline/src/phases/extract_i18n_messages.mjs

@@ -0,0 +1,157 @@
+/**
+ * @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 o from '../../../../output/output_ast';
+import * as ir from '../../ir';
+/**
+ * The escape sequence used indicate message param values.
+ */
+const ESCAPE = '\uFFFD';
+/**
+ * Marker used to indicate an element tag.
+ */
+const ELEMENT_MARKER = '#';
+/**
+ * Marker used to indicate a template tag.
+ */
+const TEMPLATE_MARKER = '*';
+/**
+ * Marker used to indicate closing of an element or template tag.
+ */
+const TAG_CLOSE_MARKER = '/';
+/**
+ * Marker used to indicate the sub-template context.
+ */
+const CONTEXT_MARKER = ':';
+/**
+ * Marker used to indicate the start of a list of values.
+ */
+const LIST_START_MARKER = '[';
+/**
+ * Marker used to indicate the end of a list of values.
+ */
+const LIST_END_MARKER = ']';
+/**
+ * Delimiter used to separate multiple values in a list.
+ */
+const LIST_DELIMITER = '|';
+/**
+ * Formats the param maps on extracted message ops into a maps of `Expression` objects that can be
+ * used in the final output.
+ */
+export function extractI18nMessages(job) {
+    // Save the i18n context ops for later use.
+    const i18nContexts = new Map();
+    // Record which contexts represent i18n blocks (any other contexts are assumed to have been
+    // created from ICUs).
+    const i18nBlockContexts = new Set();
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            switch (op.kind) {
+                case ir.OpKind.I18nContext:
+                    i18nContexts.set(op.xref, op);
+                    break;
+                case ir.OpKind.I18nStart:
+                    i18nBlockContexts.add(op.context);
+                    break;
+            }
+        }
+    }
+    // Extract messages from root i18n blocks.
+    const i18nBlockMessages = new Map();
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            if (op.kind === ir.OpKind.I18nStart && op.xref === op.root) {
+                if (!op.context) {
+                    throw Error('I18n start op should have its context set.');
+                }
+                const i18nMessageOp = createI18nMessage(job, i18nContexts.get(op.context));
+                i18nBlockMessages.set(op.xref, i18nMessageOp);
+                unit.create.push(i18nMessageOp);
+            }
+        }
+    }
+    // Extract messages from ICUs with their own sub-context.
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            if (op.kind === ir.OpKind.Icu) {
+                if (!op.context) {
+                    throw Error('ICU op should have its context set.');
+                }
+                if (!i18nBlockContexts.has(op.context)) {
+                    const i18nContext = i18nContexts.get(op.context);
+                    const subMessage = createI18nMessage(job, i18nContext, op.messagePlaceholder);
+                    unit.create.push(subMessage);
+                    const parentMessage = i18nBlockMessages.get(i18nContext.i18nBlock);
+                    parentMessage?.subMessages.push(subMessage.xref);
+                }
+                ir.OpList.remove(op);
+            }
+        }
+    }
+}
+/**
+ * Create an i18n message op from an i18n context op.
+ */
+function createI18nMessage(job, context, messagePlaceholder) {
+    let needsPostprocessing = context.postprocessingParams.size > 0;
+    for (const values of context.params.values()) {
+        if (values.length > 1) {
+            needsPostprocessing = true;
+        }
+    }
+    return ir.createI18nMessageOp(job.allocateXrefId(), context.i18nBlock, context.message, messagePlaceholder ?? null, formatParams(context.params), formatParams(context.postprocessingParams), needsPostprocessing);
+}
+/**
+ * Formats a map of `I18nParamValue[]` values into a map of `Expression` values.
+ */
+function formatParams(params) {
+    const result = new Map();
+    for (const [placeholder, placeholderValues] of [...params].sort()) {
+        const serializedValues = formatParamValues(placeholderValues);
+        if (serializedValues !== null) {
+            result.set(placeholder, o.literal(formatParamValues(placeholderValues)));
+        }
+    }
+    return result;
+}
+/**
+ * Formats an `I18nParamValue[]` into a string (or null for empty array).
+ */
+function formatParamValues(values) {
+    if (values.length === 0) {
+        return null;
+    }
+    const serializedValues = values.map(value => formatValue(value));
+    return serializedValues.length === 1 ?
+        serializedValues[0] :
+        `${LIST_START_MARKER}${serializedValues.join(LIST_DELIMITER)}${LIST_END_MARKER}`;
+}
+/**
+ * Formats a single `I18nParamValue` into a string
+ */
+function formatValue(value) {
+    let tagMarker = '';
+    let closeMarker = '';
+    if (value.flags & ir.I18nParamValueFlags.ElementTag) {
+        tagMarker = ELEMENT_MARKER;
+    }
+    else if (value.flags & ir.I18nParamValueFlags.TemplateTag) {
+        tagMarker = TEMPLATE_MARKER;
+    }
+    if (tagMarker !== '') {
+        closeMarker = value.flags & ir.I18nParamValueFlags.CloseTag ? TAG_CLOSE_MARKER : '';
+    }
+    const context = value.subTemplateIndex === null ? '' : `${CONTEXT_MARKER}${value.subTemplateIndex}`;
+    // Self-closing tags use a special form that concatenates the start and close tag values.
+    if ((value.flags & ir.I18nParamValueFlags.OpenTag) &&
+        (value.flags & ir.I18nParamValueFlags.CloseTag)) {
+        return `${ESCAPE}${tagMarker}${value.value}${context}${ESCAPE}${ESCAPE}${closeMarker}${tagMarker}${value.value}${context}${ESCAPE}`;
+    }
+    return `${ESCAPE}${closeMarker}${tagMarker}${value.value}${context}${ESCAPE}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"extract_i18n_messages.js","sourceRoot":"","sources":["../../../../../../../../../../packages/compiler/src/template/pipeline/src/phases/extract_i18n_messages.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 o from '../../../../output/output_ast';\nimport * as ir from '../../ir';\nimport {CompilationJob} from '../compilation';\n\n/**\n * The escape sequence used indicate message param values.\n */\nconst ESCAPE = '\\uFFFD';\n\n/**\n * Marker used to indicate an element tag.\n */\nconst ELEMENT_MARKER = '#';\n\n/**\n * Marker used to indicate a template tag.\n */\nconst TEMPLATE_MARKER = '*';\n\n/**\n * Marker used to indicate closing of an element or template tag.\n */\nconst TAG_CLOSE_MARKER = '/';\n\n/**\n * Marker used to indicate the sub-template context.\n */\nconst CONTEXT_MARKER = ':';\n\n/**\n * Marker used to indicate the start of a list of values.\n */\nconst LIST_START_MARKER = '[';\n\n/**\n * Marker used to indicate the end of a list of values.\n */\nconst LIST_END_MARKER = ']';\n\n/**\n * Delimiter used to separate multiple values in a list.\n */\nconst LIST_DELIMITER = '|';\n\n/**\n * Formats the param maps on extracted message ops into a maps of `Expression` objects that can be\n * used in the final output.\n */\nexport function extractI18nMessages(job: CompilationJob): void {\n  // Save the i18n context ops for later use.\n  const i18nContexts = new Map<ir.XrefId, ir.I18nContextOp>();\n  // Record which contexts represent i18n blocks (any other contexts are assumed to have been\n  // created from ICUs).\n  const i18nBlockContexts = new Set<ir.XrefId>();\n  for (const unit of job.units) {\n    for (const op of unit.create) {\n      switch (op.kind) {\n        case ir.OpKind.I18nContext:\n          i18nContexts.set(op.xref, op);\n          break;\n        case ir.OpKind.I18nStart:\n          i18nBlockContexts.add(op.context!);\n          break;\n      }\n    }\n  }\n\n  // Extract messages from root i18n blocks.\n  const i18nBlockMessages = new Map<ir.XrefId, ir.I18nMessageOp>();\n  for (const unit of job.units) {\n    for (const op of unit.create) {\n      if (op.kind === ir.OpKind.I18nStart && op.xref === op.root) {\n        if (!op.context) {\n          throw Error('I18n start op should have its context set.');\n        }\n        const i18nMessageOp = createI18nMessage(job, i18nContexts.get(op.context)!);\n        i18nBlockMessages.set(op.xref, i18nMessageOp);\n        unit.create.push(i18nMessageOp);\n      }\n    }\n  }\n\n  // Extract messages from ICUs with their own sub-context.\n  for (const unit of job.units) {\n    for (const op of unit.create) {\n      if (op.kind === ir.OpKind.Icu) {\n        if (!op.context) {\n          throw Error('ICU op should have its context set.');\n        }\n        if (!i18nBlockContexts.has(op.context)) {\n          const i18nContext = i18nContexts.get(op.context)!;\n          const subMessage = createI18nMessage(job, i18nContext, op.messagePlaceholder);\n          unit.create.push(subMessage);\n          const parentMessage = i18nBlockMessages.get(i18nContext.i18nBlock);\n          parentMessage?.subMessages.push(subMessage.xref);\n        }\n        ir.OpList.remove<ir.CreateOp>(op);\n      }\n    }\n  }\n}\n\n/**\n * Create an i18n message op from an i18n context op.\n */\nfunction createI18nMessage(\n    job: CompilationJob, context: ir.I18nContextOp, messagePlaceholder?: string): ir.I18nMessageOp {\n  let needsPostprocessing = context.postprocessingParams.size > 0;\n  for (const values of context.params.values()) {\n    if (values.length > 1) {\n      needsPostprocessing = true;\n    }\n  }\n  return ir.createI18nMessageOp(\n      job.allocateXrefId(), context.i18nBlock, context.message, messagePlaceholder ?? null,\n      formatParams(context.params), formatParams(context.postprocessingParams),\n      needsPostprocessing);\n}\n\n/**\n * Formats a map of `I18nParamValue[]` values into a map of `Expression` values.\n */\nfunction formatParams(params: Map<string, ir.I18nParamValue[]>): Map<string, o.Expression> {\n  const result = new Map<string, o.Expression>();\n  for (const [placeholder, placeholderValues] of [...params].sort()) {\n    const serializedValues = formatParamValues(placeholderValues);\n    if (serializedValues !== null) {\n      result.set(placeholder, o.literal(formatParamValues(placeholderValues)));\n    }\n  }\n  return result;\n}\n\n/**\n * Formats an `I18nParamValue[]` into a string (or null for empty array).\n */\nfunction formatParamValues(values: ir.I18nParamValue[]): string|null {\n  if (values.length === 0) {\n    return null;\n  }\n  const serializedValues = values.map(value => formatValue(value));\n  return serializedValues.length === 1 ?\n      serializedValues[0] :\n      `${LIST_START_MARKER}${serializedValues.join(LIST_DELIMITER)}${LIST_END_MARKER}`;\n}\n\n/**\n * Formats a single `I18nParamValue` into a string\n */\nfunction formatValue(value: ir.I18nParamValue): string {\n  let tagMarker = '';\n  let closeMarker = '';\n  if (value.flags & ir.I18nParamValueFlags.ElementTag) {\n    tagMarker = ELEMENT_MARKER;\n  } else if (value.flags & ir.I18nParamValueFlags.TemplateTag) {\n    tagMarker = TEMPLATE_MARKER;\n  }\n  if (tagMarker !== '') {\n    closeMarker = value.flags & ir.I18nParamValueFlags.CloseTag ? TAG_CLOSE_MARKER : '';\n  }\n  const context =\n      value.subTemplateIndex === null ? '' : `${CONTEXT_MARKER}${value.subTemplateIndex}`;\n  // Self-closing tags use a special form that concatenates the start and close tag values.\n  if ((value.flags & ir.I18nParamValueFlags.OpenTag) &&\n      (value.flags & ir.I18nParamValueFlags.CloseTag)) {\n    return `${ESCAPE}${tagMarker}${value.value}${context}${ESCAPE}${ESCAPE}${closeMarker}${\n        tagMarker}${value.value}${context}${ESCAPE}`;\n  }\n  return `${ESCAPE}${closeMarker}${tagMarker}${value.value}${context}${ESCAPE}`;\n}\n"]}

package/esm2022/src/template/pipeline/src/phases/i18n_const_collection.mjs

@@ -27,35 +27,23 @@ const TRANSLATION_VAR_PREFIX = 'i18n_';
 export function collectI18nConsts(job) {
     const fileBasedI18nSuffix = job.relativeContextFilePath.replace(/[^A-Za-z0-9]/g, '_').toUpperCase() + '_';
     const messageConstIndices = new Map();
+    // Remove all of the i18n message ops into a map.
+    const messages = new Map();
     for (const unit of job.units) {
         for (const op of unit.create) {
-            if (op.kind === ir.OpKind.ExtractedMessage) {
-                // Serialize the extracted root messages into the const array.
-                if (op.isRoot) {
-                    assertAllParamsResolved(op);
-                    const mainVar = o.variable(job.pool.uniqueName(TRANSLATION_VAR_PREFIX));
-                    // Closure Compiler requires const names to start with `MSG_` but disallows any other
-                    // const to start with `MSG_`. We define a variable starting with `MSG_` just for the
-                    // `goog.getMsg` call
-                    const closureVar = i18nGenerateClosureVar(job.pool, op.message.id, fileBasedI18nSuffix, job.i18nUseExternalIds);
-                    let transformFn = undefined;
-                    // If nescessary, add a post-processing step and resolve any placeholder params that are
-                    // set in post-processing.
-                    if (op.needsPostprocessing) {
-                        const extraTransformFnParams = [];
-                        if (op.formattedPostprocessingParams.size > 0) {
-                            extraTransformFnParams.push(o.literalMap([...op.formattedPostprocessingParams].map(([key, value]) => ({ key, value, quoted: true }))));
-                        }
-                        transformFn = (expr) => o.importExpr(Identifiers.i18nPostprocess).callFn([expr, ...extraTransformFnParams]);
-                    }
-                    const statements = getTranslationDeclStmts(op.message, mainVar, closureVar, op.formattedParams, transformFn);
-                    messageConstIndices.set(op.owner, job.addConst(mainVar, statements));
-                }
-                // Remove the extracted messages from the IR now that they have been collected.
+            if (op.kind === ir.OpKind.I18nMessage) {
+                messages.set(op.xref, op);
                 ir.OpList.remove(op);
             }
         }
     }
+    // Serialize the extracted messages for root i18n blocks into the const array.
+    for (const op of messages.values()) {
+        if (op.kind === ir.OpKind.I18nMessage && op.messagePlaceholder === null) {
+            const { mainVar, statements } = collectMessage(job, fileBasedI18nSuffix, messages, op);
+            messageConstIndices.set(op.i18nBlock, job.addConst(mainVar, statements));
+        }
+    }
     // Assign const index to i18n ops that messages were extracted from.
     for (const unit of job.units) {
         for (const op of unit.create) {
@@ -65,6 +53,40 @@ export function collectI18nConsts(job) {
         }
     }
 }
+/**
+ * Collects the given message into a set of statements that can be added to the const array.
+ * This will recursively collect any sub-messages referenced from the parent message as well.
+ */
+function collectMessage(job, fileBasedI18nSuffix, messages, messageOp) {
+    // Recursively collect any sub-messages, and fill in their placeholders in this message.
+    const statements = [];
+    for (const subMessageId of messageOp.subMessages) {
+        const subMessage = messages.get(subMessageId);
+        const { mainVar: subMessageVar, statements: subMessageStatements } = collectMessage(job, fileBasedI18nSuffix, messages, subMessage);
+        statements.push(...subMessageStatements);
+        messageOp.params.set(subMessage.messagePlaceholder, subMessageVar);
+    }
+    // Check that the message has all of its parameters filled out.
+    assertAllParamsResolved(messageOp);
+    const mainVar = o.variable(job.pool.uniqueName(TRANSLATION_VAR_PREFIX));
+    // Closure Compiler requires const names to start with `MSG_` but disallows any other
+    // const to start with `MSG_`. We define a variable starting with `MSG_` just for the
+    // `goog.getMsg` call
+    const closureVar = i18nGenerateClosureVar(job.pool, messageOp.message.id, fileBasedI18nSuffix, job.i18nUseExternalIds);
+    let transformFn = undefined;
+    // If nescessary, add a post-processing step and resolve any placeholder params that are
+    // set in post-processing.
+    if (messageOp.needsPostprocessing) {
+        const extraTransformFnParams = [];
+        if (messageOp.postprocessingParams.size > 0) {
+            extraTransformFnParams.push(o.literalMap([...messageOp.postprocessingParams].map(([key, value]) => ({ key, value, quoted: true }))));
+        }
+        transformFn = (expr) => o.importExpr(Identifiers.i18nPostprocess).callFn([expr, ...extraTransformFnParams]);
+    }
+    // Add the message's statements
+    statements.push(...getTranslationDeclStmts(messageOp.message, mainVar, closureVar, messageOp.params, transformFn));
+    return { mainVar, statements };
+}
 /**
  * Generate statements that define a given translation message.
  *
@@ -136,20 +158,15 @@ function i18nGenerateClosureVar(pool, messageId, fileBasedI18nSuffix, useExterna
  * Asserts that all of the message's placeholders have values.
  */
 function assertAllParamsResolved(op) {
-    if (op.formattedParams === null || op.formattedPostprocessingParams === null) {
-        throw Error('Params should have been formatted.');
-    }
     for (const placeholder in op.message.placeholders) {
-        if (!op.formattedParams.has(placeholder) &&
-            !op.formattedPostprocessingParams.has(placeholder)) {
+        if (!op.params.has(placeholder) && !op.postprocessingParams.has(placeholder)) {
             throw Error(`Failed to resolve i18n placeholder: ${placeholder}`);
         }
     }
     for (const placeholder in op.message.placeholderToMessage) {
-        if (!op.formattedParams.has(placeholder) &&
-            !op.formattedPostprocessingParams.has(placeholder)) {
+        if (!op.params.has(placeholder) && !op.postprocessingParams.has(placeholder)) {
             throw Error(`Failed to resolve i18n message placeholder: ${placeholder}`);
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"i18n_const_collection.js","sourceRoot":"","sources":["../../../../../../../../../../packages/compiler/src/template/pipeline/src/phases/i18n_const_collection.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 {type ConstantPool} from '../../../../constant_pool';\nimport * as i18n from '../../../../i18n/i18n_ast';\nimport * as o from '../../../../output/output_ast';\nimport {sanitizeIdentifier} from '../../../../parse_util';\nimport {Identifiers} from '../../../../render3/r3_identifiers';\nimport {createGoogleGetMsgStatements} from '../../../../render3/view/i18n/get_msg_utils';\nimport {createLocalizeStatements} from '../../../../render3/view/i18n/localize_utils';\nimport {declareI18nVariable, formatI18nPlaceholderNamesInMap, getTranslationConstPrefix} from '../../../../render3/view/i18n/util';\nimport * as ir from '../../ir';\nimport {ComponentCompilationJob} from '../compilation';\n\n/** Name of the global variable that is used to determine if we use Closure translations or not */\nconst NG_I18N_CLOSURE_MODE = 'ngI18nClosureMode';\n\n/**\n * Prefix for non-`goog.getMsg` i18n-related vars.\n * Note: the prefix uses lowercase characters intentionally due to a Closure behavior that\n * considers variables like `I18N_0` as constants and throws an error when their value changes.\n */\nconst TRANSLATION_VAR_PREFIX = 'i18n_';\n\n/**\n * Lifts i18n properties into the consts array.\n * TODO: Can we use `ConstCollectedExpr`?\n */\nexport function collectI18nConsts(job: ComponentCompilationJob): void {\n  const fileBasedI18nSuffix =\n      job.relativeContextFilePath.replace(/[^A-Za-z0-9]/g, '_').toUpperCase() + '_';\n  const messageConstIndices = new Map<ir.XrefId, ir.ConstIndex>();\n\n  for (const unit of job.units) {\n    for (const op of unit.create) {\n      if (op.kind === ir.OpKind.ExtractedMessage) {\n        // Serialize the extracted root messages into the const array.\n        if (op.isRoot) {\n          assertAllParamsResolved(op);\n\n          const mainVar = o.variable(job.pool.uniqueName(TRANSLATION_VAR_PREFIX));\n          // Closure Compiler requires const names to start with `MSG_` but disallows any other\n          // const to start with `MSG_`. We define a variable starting with `MSG_` just for the\n          // `goog.getMsg` call\n          const closureVar = i18nGenerateClosureVar(\n              job.pool, op.message.id, fileBasedI18nSuffix, job.i18nUseExternalIds);\n          let transformFn = undefined;\n\n          // If nescessary, add a post-processing step and resolve any placeholder params that are\n          // set in post-processing.\n          if (op.needsPostprocessing) {\n            const extraTransformFnParams: o.Expression[] = [];\n            if (op.formattedPostprocessingParams.size > 0) {\n              extraTransformFnParams.push(o.literalMap([...op.formattedPostprocessingParams].map(\n                  ([key, value]) => ({key, value, quoted: true}))));\n            }\n            transformFn = (expr: o.ReadVarExpr) =>\n                o.importExpr(Identifiers.i18nPostprocess).callFn([expr, ...extraTransformFnParams]);\n          }\n\n          const statements = getTranslationDeclStmts(\n              op.message, mainVar, closureVar, op.formattedParams!, transformFn);\n\n          messageConstIndices.set(op.owner, job.addConst(mainVar, statements));\n        }\n\n        // Remove the extracted messages from the IR now that they have been collected.\n        ir.OpList.remove<ir.CreateOp>(op);\n      }\n    }\n  }\n\n  // Assign const index to i18n ops that messages were extracted from.\n  for (const unit of job.units) {\n    for (const op of unit.create) {\n      if (op.kind === ir.OpKind.I18nStart) {\n        op.messageIndex = messageConstIndices.get(op.root)!;\n      }\n    }\n  }\n}\n\n/**\n * Generate statements that define a given translation message.\n *\n * ```\n * var I18N_1;\n * if (typeof ngI18nClosureMode !== undefined && ngI18nClosureMode) {\n *     var MSG_EXTERNAL_XXX = goog.getMsg(\n *          \"Some message with {$interpolation}!\",\n *          { \"interpolation\": \"\\uFFFD0\\uFFFD\" }\n *     );\n *     I18N_1 = MSG_EXTERNAL_XXX;\n * }\n * else {\n *     I18N_1 = $localize`Some message with ${'\\uFFFD0\\uFFFD'}!`;\n * }\n * ```\n *\n * @param message The original i18n AST message node\n * @param variable The variable that will be assigned the translation, e.g. `I18N_1`.\n * @param closureVar The variable for Closure `goog.getMsg` calls, e.g. `MSG_EXTERNAL_XXX`.\n * @param params Object mapping placeholder names to their values (e.g.\n * `{ \"interpolation\": \"\\uFFFD0\\uFFFD\" }`).\n * @param transformFn Optional transformation function that will be applied to the translation (e.g.\n * post-processing).\n * @returns An array of statements that defined a given translation.\n */\nfunction getTranslationDeclStmts(\n    message: i18n.Message, variable: o.ReadVarExpr, closureVar: o.ReadVarExpr,\n    params: Map<string, o.Expression>,\n    transformFn?: (raw: o.ReadVarExpr) => o.Expression): o.Statement[] {\n  const paramsObject = Object.fromEntries(params);\n  const statements: o.Statement[] = [\n    declareI18nVariable(variable),\n    o.ifStmt(\n        createClosureModeGuard(),\n        createGoogleGetMsgStatements(variable, message, closureVar, paramsObject),\n        createLocalizeStatements(\n            variable, message,\n            formatI18nPlaceholderNamesInMap(paramsObject, /* useCamelCase */ false))),\n  ];\n\n  if (transformFn) {\n    statements.push(new o.ExpressionStatement(variable.set(transformFn(variable))));\n  }\n\n  return statements;\n}\n\n/**\n * Create the expression that will be used to guard the closure mode block\n * It is equivalent to:\n *\n * ```\n * typeof ngI18nClosureMode !== undefined && ngI18nClosureMode\n * ```\n */\nfunction createClosureModeGuard(): o.BinaryOperatorExpr {\n  return o.typeofExpr(o.variable(NG_I18N_CLOSURE_MODE))\n      .notIdentical(o.literal('undefined', o.STRING_TYPE))\n      .and(o.variable(NG_I18N_CLOSURE_MODE));\n}\n\n/**\n * Generates vars with Closure-specific names for i18n blocks (i.e. `MSG_XXX`).\n */\nfunction i18nGenerateClosureVar(\n    pool: ConstantPool, messageId: string, fileBasedI18nSuffix: string,\n    useExternalIds: boolean): o.ReadVarExpr {\n  let name: string;\n  const suffix = fileBasedI18nSuffix;\n  if (useExternalIds) {\n    const prefix = getTranslationConstPrefix(`EXTERNAL_`);\n    const uniqueSuffix = pool.uniqueName(suffix);\n    name = `${prefix}${sanitizeIdentifier(messageId)}$$${uniqueSuffix}`;\n  } else {\n    const prefix = getTranslationConstPrefix(suffix);\n    name = pool.uniqueName(prefix);\n  }\n  return o.variable(name);\n}\n\n/**\n * Asserts that all of the message's placeholders have values.\n */\nfunction assertAllParamsResolved(op: ir.ExtractedMessageOp): asserts op is ir.ExtractedMessageOp&{\n  formattedParams: Map<string, o.Expression>,\n  formattedPostprocessingParams: Map<string, o.Expression>,\n} {\n  if (op.formattedParams === null || op.formattedPostprocessingParams === null) {\n    throw Error('Params should have been formatted.');\n  }\n  for (const placeholder in op.message.placeholders) {\n    if (!op.formattedParams.has(placeholder) &&\n        !op.formattedPostprocessingParams.has(placeholder)) {\n      throw Error(`Failed to resolve i18n placeholder: ${placeholder}`);\n    }\n  }\n  for (const placeholder in op.message.placeholderToMessage) {\n    if (!op.formattedParams.has(placeholder) &&\n        !op.formattedPostprocessingParams.has(placeholder)) {\n      throw Error(`Failed to resolve i18n message placeholder: ${placeholder}`);\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"i18n_const_collection.js","sourceRoot":"","sources":["../../../../../../../../../../packages/compiler/src/template/pipeline/src/phases/i18n_const_collection.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 {type ConstantPool} from '../../../../constant_pool';\nimport * as i18n from '../../../../i18n/i18n_ast';\nimport * as o from '../../../../output/output_ast';\nimport {sanitizeIdentifier} from '../../../../parse_util';\nimport {Identifiers} from '../../../../render3/r3_identifiers';\nimport {createGoogleGetMsgStatements} from '../../../../render3/view/i18n/get_msg_utils';\nimport {createLocalizeStatements} from '../../../../render3/view/i18n/localize_utils';\nimport {declareI18nVariable, formatI18nPlaceholderNamesInMap, getTranslationConstPrefix} from '../../../../render3/view/i18n/util';\nimport * as ir from '../../ir';\nimport {ComponentCompilationJob} from '../compilation';\n\n/** Name of the global variable that is used to determine if we use Closure translations or not */\nconst NG_I18N_CLOSURE_MODE = 'ngI18nClosureMode';\n\n/**\n * Prefix for non-`goog.getMsg` i18n-related vars.\n * Note: the prefix uses lowercase characters intentionally due to a Closure behavior that\n * considers variables like `I18N_0` as constants and throws an error when their value changes.\n */\nconst TRANSLATION_VAR_PREFIX = 'i18n_';\n\n/**\n * Lifts i18n properties into the consts array.\n * TODO: Can we use `ConstCollectedExpr`?\n */\nexport function collectI18nConsts(job: ComponentCompilationJob): void {\n  const fileBasedI18nSuffix =\n      job.relativeContextFilePath.replace(/[^A-Za-z0-9]/g, '_').toUpperCase() + '_';\n  const messageConstIndices = new Map<ir.XrefId, ir.ConstIndex>();\n\n  // Remove all of the i18n message ops into a map.\n  const messages = new Map<ir.XrefId, ir.I18nMessageOp>();\n  for (const unit of job.units) {\n    for (const op of unit.create) {\n      if (op.kind === ir.OpKind.I18nMessage) {\n        messages.set(op.xref, op);\n        ir.OpList.remove<ir.CreateOp>(op);\n      }\n    }\n  }\n\n  // Serialize the extracted messages for root i18n blocks into the const array.\n  for (const op of messages.values()) {\n    if (op.kind === ir.OpKind.I18nMessage && op.messagePlaceholder === null) {\n      const {mainVar, statements} = collectMessage(job, fileBasedI18nSuffix, messages, op);\n      messageConstIndices.set(op.i18nBlock, job.addConst(mainVar, statements));\n    }\n  }\n\n  // Assign const index to i18n ops that messages were extracted from.\n  for (const unit of job.units) {\n    for (const op of unit.create) {\n      if (op.kind === ir.OpKind.I18nStart) {\n        op.messageIndex = messageConstIndices.get(op.root)!;\n      }\n    }\n  }\n}\n\n/**\n * Collects the given message into a set of statements that can be added to the const array.\n * This will recursively collect any sub-messages referenced from the parent message as well.\n */\nfunction collectMessage(\n    job: ComponentCompilationJob, fileBasedI18nSuffix: string,\n    messages: Map<ir.XrefId, ir.I18nMessageOp>,\n    messageOp: ir.I18nMessageOp): {mainVar: o.ReadVarExpr, statements: o.Statement[]} {\n  // Recursively collect any sub-messages, and fill in their placeholders in this message.\n  const statements: o.Statement[] = [];\n  for (const subMessageId of messageOp.subMessages) {\n    const subMessage = messages.get(subMessageId)!;\n    const {mainVar: subMessageVar, statements: subMessageStatements} =\n        collectMessage(job, fileBasedI18nSuffix, messages, subMessage);\n    statements.push(...subMessageStatements);\n    messageOp.params.set(subMessage.messagePlaceholder!, subMessageVar);\n  }\n\n  // Check that the message has all of its parameters filled out.\n  assertAllParamsResolved(messageOp);\n\n  const mainVar = o.variable(job.pool.uniqueName(TRANSLATION_VAR_PREFIX));\n  // Closure Compiler requires const names to start with `MSG_` but disallows any other\n  // const to start with `MSG_`. We define a variable starting with `MSG_` just for the\n  // `goog.getMsg` call\n  const closureVar = i18nGenerateClosureVar(\n      job.pool, messageOp.message.id, fileBasedI18nSuffix, job.i18nUseExternalIds);\n  let transformFn = undefined;\n\n  // If nescessary, add a post-processing step and resolve any placeholder params that are\n  // set in post-processing.\n  if (messageOp.needsPostprocessing) {\n    const extraTransformFnParams: o.Expression[] = [];\n    if (messageOp.postprocessingParams.size > 0) {\n      extraTransformFnParams.push(o.literalMap(\n          [...messageOp.postprocessingParams].map(([key, value]) => ({key, value, quoted: true}))));\n    }\n    transformFn = (expr: o.ReadVarExpr) =>\n        o.importExpr(Identifiers.i18nPostprocess).callFn([expr, ...extraTransformFnParams]);\n  }\n\n  // Add the message's statements\n  statements.push(...getTranslationDeclStmts(\n      messageOp.message, mainVar, closureVar, messageOp.params, transformFn));\n\n  return {mainVar, statements};\n}\n\n/**\n * Generate statements that define a given translation message.\n *\n * ```\n * var I18N_1;\n * if (typeof ngI18nClosureMode !== undefined && ngI18nClosureMode) {\n *     var MSG_EXTERNAL_XXX = goog.getMsg(\n *          \"Some message with {$interpolation}!\",\n *          { \"interpolation\": \"\\uFFFD0\\uFFFD\" }\n *     );\n *     I18N_1 = MSG_EXTERNAL_XXX;\n * }\n * else {\n *     I18N_1 = $localize`Some message with ${'\\uFFFD0\\uFFFD'}!`;\n * }\n * ```\n *\n * @param message The original i18n AST message node\n * @param variable The variable that will be assigned the translation, e.g. `I18N_1`.\n * @param closureVar The variable for Closure `goog.getMsg` calls, e.g. `MSG_EXTERNAL_XXX`.\n * @param params Object mapping placeholder names to their values (e.g.\n * `{ \"interpolation\": \"\\uFFFD0\\uFFFD\" }`).\n * @param transformFn Optional transformation function that will be applied to the translation (e.g.\n * post-processing).\n * @returns An array of statements that defined a given translation.\n */\nfunction getTranslationDeclStmts(\n    message: i18n.Message, variable: o.ReadVarExpr, closureVar: o.ReadVarExpr,\n    params: Map<string, o.Expression>,\n    transformFn?: (raw: o.ReadVarExpr) => o.Expression): o.Statement[] {\n  const paramsObject = Object.fromEntries(params);\n  const statements: o.Statement[] = [\n    declareI18nVariable(variable),\n    o.ifStmt(\n        createClosureModeGuard(),\n        createGoogleGetMsgStatements(variable, message, closureVar, paramsObject),\n        createLocalizeStatements(\n            variable, message,\n            formatI18nPlaceholderNamesInMap(paramsObject, /* useCamelCase */ false))),\n  ];\n\n  if (transformFn) {\n    statements.push(new o.ExpressionStatement(variable.set(transformFn(variable))));\n  }\n\n  return statements;\n}\n\n/**\n * Create the expression that will be used to guard the closure mode block\n * It is equivalent to:\n *\n * ```\n * typeof ngI18nClosureMode !== undefined && ngI18nClosureMode\n * ```\n */\nfunction createClosureModeGuard(): o.BinaryOperatorExpr {\n  return o.typeofExpr(o.variable(NG_I18N_CLOSURE_MODE))\n      .notIdentical(o.literal('undefined', o.STRING_TYPE))\n      .and(o.variable(NG_I18N_CLOSURE_MODE));\n}\n\n/**\n * Generates vars with Closure-specific names for i18n blocks (i.e. `MSG_XXX`).\n */\nfunction i18nGenerateClosureVar(\n    pool: ConstantPool, messageId: string, fileBasedI18nSuffix: string,\n    useExternalIds: boolean): o.ReadVarExpr {\n  let name: string;\n  const suffix = fileBasedI18nSuffix;\n  if (useExternalIds) {\n    const prefix = getTranslationConstPrefix(`EXTERNAL_`);\n    const uniqueSuffix = pool.uniqueName(suffix);\n    name = `${prefix}${sanitizeIdentifier(messageId)}$$${uniqueSuffix}`;\n  } else {\n    const prefix = getTranslationConstPrefix(suffix);\n    name = pool.uniqueName(prefix);\n  }\n  return o.variable(name);\n}\n\n/**\n * Asserts that all of the message's placeholders have values.\n */\nfunction assertAllParamsResolved(op: ir.I18nMessageOp): asserts op is ir.I18nMessageOp {\n  for (const placeholder in op.message.placeholders) {\n    if (!op.params.has(placeholder) && !op.postprocessingParams.has(placeholder)) {\n      throw Error(`Failed to resolve i18n placeholder: ${placeholder}`);\n    }\n  }\n  for (const placeholder in op.message.placeholderToMessage) {\n    if (!op.params.has(placeholder) && !op.postprocessingParams.has(placeholder)) {\n      throw Error(`Failed to resolve i18n message placeholder: ${placeholder}`);\n    }\n  }\n}\n"]}

package/esm2022/src/template/pipeline/src/phases/i18n_text_extraction.mjs

@@ -13,22 +13,22 @@ export function extractI18nText(job) {
     for (const unit of job.units) {
         // Remove all text nodes within i18n blocks, their content is already captured in the i18n
         // message.
-        let currentI18nId = null;
-        let currentI18nSlot = null;
-        const textNodes = new Map();
+        let currentI18n = null;
+        const textNodeI18nBlocks = new Map();
         for (const op of unit.create) {
             switch (op.kind) {
                 case ir.OpKind.I18nStart:
-                    currentI18nId = op.xref;
-                    currentI18nSlot = op.handle;
+                    if (op.context === null) {
+                        throw Error('I18n op should have its context set.');
+                    }
+                    currentI18n = op;
                     break;
                 case ir.OpKind.I18nEnd:
-                    currentI18nId = null;
-                    currentI18nSlot = null;
+                    currentI18n = null;
                     break;
                 case ir.OpKind.Text:
-                    if (currentI18nId !== null && currentI18nSlot !== null) {
-                        textNodes.set(op.xref, { xref: currentI18nId, slot: currentI18nSlot });
+                    if (currentI18n !== null) {
+                        textNodeI18nBlocks.set(op.xref, currentI18n);
                         ir.OpList.remove(op);
                     }
                     break;
@@ -39,18 +39,17 @@ export function extractI18nText(job) {
         for (const op of unit.update) {
             switch (op.kind) {
                 case ir.OpKind.InterpolateText:
-                    if (!textNodes.has(op.target)) {
+                    if (!textNodeI18nBlocks.has(op.target)) {
                         continue;
                     }
-                    const i18nBlock = textNodes.get(op.target);
+                    const i18nOp = textNodeI18nBlocks.get(op.target);
                     const ops = [];
                     for (let i = 0; i < op.interpolation.expressions.length; i++) {
                         const expr = op.interpolation.expressions[i];
                         const placeholder = op.i18nPlaceholders[i];
-                        ops.push(ir.createI18nExpressionOp(i18nBlock.xref, i18nBlock.slot, expr, placeholder.name, ir.I18nParamResolutionTime.Creation, expr.sourceSpan ?? op.sourceSpan));
-                    }
-                    if (ops.length > 0) {
-                        // ops.push(ir.createI18nApplyOp(i18nBlockId, op.i18nPlaceholders, op.sourceSpan));
+                        // For now, this i18nExpression depends on the slot context of the enclosing i18n block.
+                        // Later, we will modify this, and advance to a different point.
+                        ops.push(ir.createI18nExpressionOp(i18nOp.context, i18nOp.xref, i18nOp.handle, expr, placeholder.name, ir.I18nParamResolutionTime.Creation, expr.sourceSpan ?? op.sourceSpan));
                     }
                     ir.OpList.replaceWithMany(op, ops);
                     break;
@@ -58,4 +57,4 @@ export function extractI18nText(job) {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/template/pipeline/src/phases/merge_i18n_contexts.mjs

@@ -0,0 +1,59 @@
+/**
+ * @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 ir from '../../ir';
+/**
+ * Merge i18n contexts for child i18n blocks into their ancestor root contexts.
+ */
+export function mergeI18nContexts(job) {
+    // Record all of the i18n and extracted message ops for use later.
+    const i18nOps = new Map();
+    const i18nContexts = new Map();
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            switch (op.kind) {
+                case ir.OpKind.I18nStart:
+                    if (!op.context) {
+                        throw Error('I18n op should have its context set.');
+                    }
+                    i18nOps.set(op.xref, op);
+                    break;
+                case ir.OpKind.I18nContext:
+                    i18nContexts.set(op.xref, op);
+                    break;
+            }
+        }
+    }
+    // For each non-root i18n op, merge its context into the root i18n op's context.
+    for (const childI18nOp of i18nOps.values()) {
+        if (childI18nOp.xref !== childI18nOp.root) {
+            const childContext = i18nContexts.get(childI18nOp.context);
+            const rootI18nOp = i18nOps.get(childI18nOp.root);
+            const rootContext = i18nContexts.get(rootI18nOp.context);
+            mergeParams(rootContext.params, childContext.params);
+            mergeParams(rootContext.postprocessingParams, childContext.postprocessingParams);
+        }
+    }
+}
+/**
+ * Merges the params in the `from` map to into the `to` map.
+ */
+function mergeParams(to, from) {
+    for (const [placeholder, fromValues] of from) {
+        const toValues = to.get(placeholder) || [];
+        // TODO(mmalerba): Child element close tag params should be prepended to maintain the same order
+        // as TemplateDefinitionBuilder. Can be cleaned up when compatibility is no longer required.
+        const flags = fromValues[0].flags;
+        if ((flags & ir.I18nParamValueFlags.CloseTag) && !(flags & ir.I18nParamValueFlags.OpenTag)) {
+            to.set(placeholder, [...fromValues, ...toValues]);
+        }
+        else {
+            to.set(placeholder, [...toValues, ...fromValues]);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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