@angular/core 18.0.0-next.2 → 18.0.0-next.4

package/esm2022/src/hydration/i18n.mjs

@@ -0,0 +1,378 @@
+/**
+ * @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 { inject, Injector } from '../di';
+import { isRootTemplateMessage } from '../render3/i18n/i18n_util';
+import { HEADER_OFFSET, HYDRATION, RENDERER, TVIEW } from '../render3/interfaces/view';
+import { nativeRemoveNode } from '../render3/node_manipulation';
+import { unwrapRNode } from '../render3/util/view_utils';
+import { assertDefined, assertNotEqual } from '../util/assert';
+import { I18N_DATA } from './interfaces';
+import { locateNextRNode, tryLocateRNodeByPath } from './node_lookup_utils';
+import { IS_I18N_HYDRATION_ENABLED } from './tokens';
+import { getNgContainerSize, initDisconnectedNodes, isSerializedElementContainer, processTextNodeBeforeSerialization } from './utils';
+let _isI18nHydrationSupportEnabled = false;
+let _prepareI18nBlockForHydrationImpl = () => {
+    // noop unless `enablePrepareI18nBlockForHydrationImpl` is invoked.
+};
+export function setIsI18nHydrationSupportEnabled(enabled) {
+    _isI18nHydrationSupportEnabled = enabled;
+}
+export function isI18nHydrationSupportEnabled() {
+    return _isI18nHydrationSupportEnabled;
+}
+/**
+ * Prepares an i18n block and its children, located at the given
+ * view and instruction index, for hydration.
+ *
+ * @param lView lView with the i18n block
+ * @param index index of the i18n block in the lView
+ * @param parentTNode TNode of the parent of the i18n block
+ * @param subTemplateIndex sub-template index, or -1 for the main template
+ */
+export function prepareI18nBlockForHydration(lView, index, parentTNode, subTemplateIndex) {
+    _prepareI18nBlockForHydrationImpl(lView, index, parentTNode, subTemplateIndex);
+}
+export function enablePrepareI18nBlockForHydrationImpl() {
+    _prepareI18nBlockForHydrationImpl = prepareI18nBlockForHydrationImpl;
+}
+export function isI18nHydrationEnabled(injector) {
+    injector = injector ?? inject(Injector);
+    return injector.get(IS_I18N_HYDRATION_ENABLED, false);
+}
+/**
+ * Collects, if not already cached, all of the indices in the
+ * given TView which are children of an i18n block.
+ *
+ * Since i18n blocks don't introduce a parent TNode, this is necessary
+ * in order to determine which indices in a LView are translated.
+ */
+export function getOrComputeI18nChildren(tView, context) {
+    let i18nChildren = context.i18nChildren.get(tView);
+    if (i18nChildren === undefined) {
+        i18nChildren = collectI18nChildren(tView);
+        context.i18nChildren.set(tView, i18nChildren);
+    }
+    return i18nChildren;
+}
+function collectI18nChildren(tView) {
+    const children = new Set();
+    function collectI18nViews(node) {
+        children.add(node.index);
+        switch (node.kind) {
+            case 1 /* I18nNodeKind.ELEMENT */:
+            case 2 /* I18nNodeKind.PLACEHOLDER */: {
+                for (const childNode of node.children) {
+                    collectI18nViews(childNode);
+                }
+                break;
+            }
+            case 3 /* I18nNodeKind.ICU */: {
+                for (const caseNodes of node.cases) {
+                    for (const caseNode of caseNodes) {
+                        collectI18nViews(caseNode);
+                    }
+                }
+                break;
+            }
+        }
+    }
+    // Traverse through the AST of each i18n block in the LView,
+    // and collect every instruction index.
+    for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {
+        const tI18n = tView.data[i];
+        if (!tI18n || !tI18n.ast) {
+            continue;
+        }
+        for (const node of tI18n.ast) {
+            collectI18nViews(node);
+        }
+    }
+    return children.size === 0 ? null : children;
+}
+/**
+ * Attempts to serialize i18n data for an i18n block, located at
+ * the given view and instruction index.
+ *
+ * @param lView lView with the i18n block
+ * @param index index of the i18n block in the lView
+ * @param context the hydration context
+ * @returns the i18n data, or null if there is no relevant data
+ */
+export function trySerializeI18nBlock(lView, index, context) {
+    if (!context.isI18nHydrationEnabled) {
+        return null;
+    }
+    const tView = lView[TVIEW];
+    const tI18n = tView.data[index];
+    if (!tI18n || !tI18n.ast) {
+        return null;
+    }
+    const caseQueue = [];
+    tI18n.ast.forEach(node => serializeI18nBlock(lView, caseQueue, context, node));
+    return caseQueue.length > 0 ? caseQueue : null;
+}
+function serializeI18nBlock(lView, caseQueue, context, node) {
+    switch (node.kind) {
+        case 0 /* I18nNodeKind.TEXT */:
+            const rNode = unwrapRNode(lView[node.index]);
+            processTextNodeBeforeSerialization(context, rNode);
+            break;
+        case 1 /* I18nNodeKind.ELEMENT */:
+        case 2 /* I18nNodeKind.PLACEHOLDER */:
+            node.children.forEach(node => serializeI18nBlock(lView, caseQueue, context, node));
+            break;
+        case 3 /* I18nNodeKind.ICU */:
+            const currentCase = lView[node.currentCaseLViewIndex];
+            if (currentCase != null) {
+                // i18n uses a negative value to signal a change to a new case, so we
+                // need to invert it to get the proper value.
+                const caseIdx = currentCase < 0 ? ~currentCase : currentCase;
+                caseQueue.push(caseIdx);
+                node.cases[caseIdx].forEach(node => serializeI18nBlock(lView, caseQueue, context, node));
+            }
+            break;
+    }
+}
+function setCurrentNode(state, node) {
+    state.currentNode = node;
+}
+/**
+ * Marks the current RNode as the hydration root for the given
+ * AST node.
+ */
+function appendI18nNodeToCollection(context, state, astNode) {
+    const noOffsetIndex = astNode.index - HEADER_OFFSET;
+    const { disconnectedNodes } = context;
+    const currentNode = state.currentNode;
+    if (state.isConnected) {
+        context.i18nNodes.set(noOffsetIndex, currentNode);
+        // We expect the node to be connected, so ensure that it
+        // is not in the set, regardless of whether we found it,
+        // so that the downstream error handling can provide the
+        // proper context.
+        disconnectedNodes.delete(noOffsetIndex);
+    }
+    else {
+        disconnectedNodes.add(noOffsetIndex);
+    }
+    return currentNode;
+}
+/**
+ * Skip over some sibling nodes during hydration.
+ *
+ * Note: we use this instead of `siblingAfter` as it's expected that
+ * sometimes we might encounter null nodes. In those cases, we want to
+ * defer to downstream error handling to provide proper context.
+ */
+function skipSiblingNodes(state, skip) {
+    let currentNode = state.currentNode;
+    for (let i = 0; i < skip; i++) {
+        if (!currentNode) {
+            break;
+        }
+        currentNode = currentNode?.nextSibling ?? null;
+    }
+    return currentNode;
+}
+/**
+ * Fork the given state into a new state for hydrating children.
+ */
+function forkHydrationState(state, nextNode) {
+    return { currentNode: nextNode, isConnected: state.isConnected };
+}
+function prepareI18nBlockForHydrationImpl(lView, index, parentTNode, subTemplateIndex) {
+    if (!isI18nHydrationSupportEnabled()) {
+        return;
+    }
+    const hydrationInfo = lView[HYDRATION];
+    if (!hydrationInfo) {
+        return;
+    }
+    const tView = lView[TVIEW];
+    const tI18n = tView.data[index];
+    ngDevMode &&
+        assertDefined(tI18n, 'Expected i18n data to be present in a given TView slot during hydration');
+    function findHydrationRoot() {
+        if (isRootTemplateMessage(subTemplateIndex)) {
+            // This is the root of an i18n block. In this case, our hydration root will
+            // depend on where our parent TNode (i.e. the block with i18n applied) is
+            // in the DOM.
+            ngDevMode && assertDefined(parentTNode, 'Expected parent TNode while hydrating i18n root');
+            const rootNode = locateNextRNode(hydrationInfo, tView, lView, parentTNode);
+            // If this i18n block is attached to an <ng-container>, then we want to begin
+            // hydrating directly with the RNode. Otherwise, for a TNode with a physical DOM
+            // element, we want to recurse into the first child and begin there.
+            return (parentTNode.type & 8 /* TNodeType.ElementContainer */) ? rootNode : rootNode.firstChild;
+        }
+        // This is a nested template in an i18n block. In this case, the entire view
+        // is translated, and part of a dehydrated view in a container. This means that
+        // we can simply begin hydration with the first dehydrated child.
+        return hydrationInfo?.firstChild;
+    }
+    const currentNode = findHydrationRoot();
+    ngDevMode && assertDefined(currentNode, 'Expected root i18n node during hydration');
+    const disconnectedNodes = initDisconnectedNodes(hydrationInfo) ?? new Set();
+    const i18nNodes = hydrationInfo.i18nNodes ??= new Map();
+    const caseQueue = hydrationInfo.data[I18N_DATA]?.[index - HEADER_OFFSET] ?? [];
+    const dehydratedIcuData = hydrationInfo.dehydratedIcuData ??=
+        new Map();
+    collectI18nNodesFromDom({ hydrationInfo, lView, i18nNodes, disconnectedNodes, caseQueue, dehydratedIcuData }, { currentNode, isConnected: true }, tI18n.ast);
+    // Nodes from inactive ICU cases should be considered disconnected. We track them above
+    // because they aren't (and shouldn't be) serialized. Since we may mutate or create a
+    // new set, we need to be sure to write the expected value back to the DehydratedView.
+    hydrationInfo.disconnectedNodes = disconnectedNodes.size === 0 ? null : disconnectedNodes;
+}
+function collectI18nNodesFromDom(context, state, nodeOrNodes) {
+    if (Array.isArray(nodeOrNodes)) {
+        for (const node of nodeOrNodes) {
+            // If the node is being projected elsewhere, we need to temporarily
+            // branch the state to that location to continue hydration.
+            // Otherwise, we continue hydration from the current location.
+            const targetNode = tryLocateRNodeByPath(context.hydrationInfo, context.lView, node.index - HEADER_OFFSET);
+            const nextState = targetNode ? forkHydrationState(state, targetNode) : state;
+            collectI18nNodesFromDom(context, nextState, node);
+        }
+    }
+    else {
+        switch (nodeOrNodes.kind) {
+            case 0 /* I18nNodeKind.TEXT */: {
+                // Claim a text node for hydration
+                const currentNode = appendI18nNodeToCollection(context, state, nodeOrNodes);
+                setCurrentNode(state, currentNode?.nextSibling ?? null);
+                break;
+            }
+            case 1 /* I18nNodeKind.ELEMENT */: {
+                // Recurse into the current element's children...
+                collectI18nNodesFromDom(context, forkHydrationState(state, state.currentNode?.firstChild ?? null), nodeOrNodes.children);
+                // And claim the parent element itself.
+                const currentNode = appendI18nNodeToCollection(context, state, nodeOrNodes);
+                setCurrentNode(state, currentNode?.nextSibling ?? null);
+                break;
+            }
+            case 2 /* I18nNodeKind.PLACEHOLDER */: {
+                const noOffsetIndex = nodeOrNodes.index - HEADER_OFFSET;
+                const { hydrationInfo } = context;
+                const containerSize = getNgContainerSize(hydrationInfo, noOffsetIndex);
+                switch (nodeOrNodes.type) {
+                    case 0 /* I18nPlaceholderType.ELEMENT */: {
+                        // Hydration expects to find the head of the element.
+                        const currentNode = appendI18nNodeToCollection(context, state, nodeOrNodes);
+                        // A TNode for the node may not yet if we're hydrating during the first pass,
+                        // so use the serialized data to determine if this is an <ng-container>.
+                        if (isSerializedElementContainer(hydrationInfo, noOffsetIndex)) {
+                            // An <ng-container> doesn't have a physical DOM node, so we need to
+                            // continue hydrating from siblings.
+                            collectI18nNodesFromDom(context, state, nodeOrNodes.children);
+                            // Skip over the anchor element. It will be claimed by the
+                            // downstream container hydration.
+                            const nextNode = skipSiblingNodes(state, 1);
+                            setCurrentNode(state, nextNode);
+                        }
+                        else {
+                            // Non-container elements represent an actual node in the DOM, so we
+                            // need to continue hydration with the children, and claim the node.
+                            collectI18nNodesFromDom(context, forkHydrationState(state, state.currentNode?.firstChild ?? null), nodeOrNodes.children);
+                            setCurrentNode(state, currentNode?.nextSibling ?? null);
+                            // Elements can also be the anchor of a view container, so there may
+                            // be elements after this node that we need to skip.
+                            if (containerSize !== null) {
+                                // `+1` stands for an anchor node after all of the views in the container.
+                                const nextNode = skipSiblingNodes(state, containerSize + 1);
+                                setCurrentNode(state, nextNode);
+                            }
+                        }
+                        break;
+                    }
+                    case 1 /* I18nPlaceholderType.SUBTEMPLATE */: {
+                        ngDevMode &&
+                            assertNotEqual(containerSize, null, 'Expected a container size while hydrating i18n subtemplate');
+                        // Hydration expects to find the head of the template.
+                        appendI18nNodeToCollection(context, state, nodeOrNodes);
+                        // Skip over all of the template children, as well as the anchor
+                        // node, since the template itself will handle them instead.
+                        const nextNode = skipSiblingNodes(state, containerSize + 1);
+                        setCurrentNode(state, nextNode);
+                        break;
+                    }
+                }
+                break;
+            }
+            case 3 /* I18nNodeKind.ICU */: {
+                // If the current node is connected, we need to pop the next case from the
+                // queue, so that the active case is also considered connected.
+                const selectedCase = state.isConnected ? context.caseQueue.shift() : null;
+                const childState = { currentNode: null, isConnected: false };
+                // We traverse through each case, even if it's not active,
+                // so that we correctly populate disconnected nodes.
+                for (let i = 0; i < nodeOrNodes.cases.length; i++) {
+                    collectI18nNodesFromDom(context, i === selectedCase ? state : childState, nodeOrNodes.cases[i]);
+                }
+                if (selectedCase !== null) {
+                    // ICUs represent a branching state, and the selected case could be different
+                    // than what it was on the server. In that case, we need to be able to clean
+                    // up the nodes from the original case. To do that, we store the selected case.
+                    context.dehydratedIcuData.set(nodeOrNodes.index, { case: selectedCase, node: nodeOrNodes });
+                }
+                // Hydration expects to find the ICU anchor element.
+                const currentNode = appendI18nNodeToCollection(context, state, nodeOrNodes);
+                setCurrentNode(state, currentNode?.nextSibling ?? null);
+                break;
+            }
+        }
+    }
+}
+let _claimDehydratedIcuCaseImpl = () => {
+    // noop unless `enableClaimDehydratedIcuCaseImpl` is invoked
+};
+/**
+ * Mark the case for the ICU node at the given index in the view as claimed,
+ * allowing its nodes to be hydrated and not cleaned up.
+ */
+export function claimDehydratedIcuCase(lView, icuIndex, caseIndex) {
+    _claimDehydratedIcuCaseImpl(lView, icuIndex, caseIndex);
+}
+export function enableClaimDehydratedIcuCaseImpl() {
+    _claimDehydratedIcuCaseImpl = claimDehydratedIcuCaseImpl;
+}
+function claimDehydratedIcuCaseImpl(lView, icuIndex, caseIndex) {
+    const dehydratedIcuDataMap = lView[HYDRATION]?.dehydratedIcuData;
+    if (dehydratedIcuDataMap) {
+        const dehydratedIcuData = dehydratedIcuDataMap.get(icuIndex);
+        if (dehydratedIcuData?.case === caseIndex) {
+            // If the case we're attempting to claim matches the dehydrated one,
+            // we remove it from the map to mark it as "claimed."
+            dehydratedIcuDataMap.delete(icuIndex);
+        }
+    }
+}
+/**
+ * Clean up all i18n hydration data associated with the given view.
+ */
+export function cleanupI18nHydrationData(lView) {
+    const hydrationInfo = lView[HYDRATION];
+    if (hydrationInfo) {
+        const { i18nNodes, dehydratedIcuData: dehydratedIcuDataMap } = hydrationInfo;
+        if (i18nNodes && dehydratedIcuDataMap) {
+            const renderer = lView[RENDERER];
+            for (const dehydratedIcuData of dehydratedIcuDataMap.values()) {
+                cleanupDehydratedIcuData(renderer, i18nNodes, dehydratedIcuData);
+            }
+        }
+        hydrationInfo.i18nNodes = undefined;
+        hydrationInfo.dehydratedIcuData = undefined;
+    }
+}
+function cleanupDehydratedIcuData(renderer, i18nNodes, dehydratedIcuData) {
+    for (const node of dehydratedIcuData.node.cases[dehydratedIcuData.case]) {
+        const rNode = i18nNodes.get(node.index - HEADER_OFFSET);
+        if (rNode) {
+            nativeRemoveNode(renderer, rNode, false);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"i18n.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/hydration/i18n.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 {inject, Injector} from '../di';\nimport {isRootTemplateMessage} from '../render3/i18n/i18n_util';\nimport {I18nNode, I18nNodeKind, I18nPlaceholderType, TI18n} from '../render3/interfaces/i18n';\nimport {TNode, TNodeType} from '../render3/interfaces/node';\nimport type {Renderer} from '../render3/interfaces/renderer';\nimport type {RNode} from '../render3/interfaces/renderer_dom';\nimport {HEADER_OFFSET, HYDRATION, LView, RENDERER, TView, TVIEW} from '../render3/interfaces/view';\nimport {nativeRemoveNode} from '../render3/node_manipulation';\nimport {unwrapRNode} from '../render3/util/view_utils';\nimport {assertDefined, assertNotEqual} from '../util/assert';\n\nimport type {HydrationContext} from './annotate';\nimport {DehydratedIcuData, DehydratedView, I18N_DATA} from './interfaces';\nimport {locateNextRNode, tryLocateRNodeByPath} from './node_lookup_utils';\nimport {IS_I18N_HYDRATION_ENABLED} from './tokens';\nimport {getNgContainerSize, initDisconnectedNodes, isSerializedElementContainer, processTextNodeBeforeSerialization} from './utils';\n\nlet _isI18nHydrationSupportEnabled = false;\n\nlet _prepareI18nBlockForHydrationImpl: typeof prepareI18nBlockForHydrationImpl = () => {\n  // noop unless `enablePrepareI18nBlockForHydrationImpl` is invoked.\n};\n\nexport function setIsI18nHydrationSupportEnabled(enabled: boolean) {\n  _isI18nHydrationSupportEnabled = enabled;\n}\n\nexport function isI18nHydrationSupportEnabled() {\n  return _isI18nHydrationSupportEnabled;\n}\n\n/**\n * Prepares an i18n block and its children, located at the given\n * view and instruction index, for hydration.\n *\n * @param lView lView with the i18n block\n * @param index index of the i18n block in the lView\n * @param parentTNode TNode of the parent of the i18n block\n * @param subTemplateIndex sub-template index, or -1 for the main template\n */\nexport function prepareI18nBlockForHydration(\n    lView: LView, index: number, parentTNode: TNode|null, subTemplateIndex: number): void {\n  _prepareI18nBlockForHydrationImpl(lView, index, parentTNode, subTemplateIndex);\n}\n\nexport function enablePrepareI18nBlockForHydrationImpl() {\n  _prepareI18nBlockForHydrationImpl = prepareI18nBlockForHydrationImpl;\n}\n\nexport function isI18nHydrationEnabled(injector?: Injector) {\n  injector = injector ?? inject(Injector);\n  return injector.get(IS_I18N_HYDRATION_ENABLED, false);\n}\n\n/**\n * Collects, if not already cached, all of the indices in the\n * given TView which are children of an i18n block.\n *\n * Since i18n blocks don't introduce a parent TNode, this is necessary\n * in order to determine which indices in a LView are translated.\n */\nexport function getOrComputeI18nChildren(tView: TView, context: HydrationContext): Set<number>|\n    null {\n  let i18nChildren = context.i18nChildren.get(tView);\n  if (i18nChildren === undefined) {\n    i18nChildren = collectI18nChildren(tView);\n    context.i18nChildren.set(tView, i18nChildren);\n  }\n  return i18nChildren;\n}\n\nfunction collectI18nChildren(tView: TView): Set<number>|null {\n  const children = new Set<number>();\n\n  function collectI18nViews(node: I18nNode) {\n    children.add(node.index);\n\n    switch (node.kind) {\n      case I18nNodeKind.ELEMENT:\n      case I18nNodeKind.PLACEHOLDER: {\n        for (const childNode of node.children) {\n          collectI18nViews(childNode);\n        }\n        break;\n      }\n\n      case I18nNodeKind.ICU: {\n        for (const caseNodes of node.cases) {\n          for (const caseNode of caseNodes) {\n            collectI18nViews(caseNode);\n          }\n        }\n        break;\n      }\n    }\n  }\n\n  // Traverse through the AST of each i18n block in the LView,\n  // and collect every instruction index.\n  for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {\n    const tI18n = tView.data[i] as TI18n | undefined;\n    if (!tI18n || !tI18n.ast) {\n      continue;\n    }\n\n    for (const node of tI18n.ast) {\n      collectI18nViews(node);\n    }\n  }\n\n  return children.size === 0 ? null : children;\n}\n\n/**\n * Attempts to serialize i18n data for an i18n block, located at\n * the given view and instruction index.\n *\n * @param lView lView with the i18n block\n * @param index index of the i18n block in the lView\n * @param context the hydration context\n * @returns the i18n data, or null if there is no relevant data\n */\nexport function trySerializeI18nBlock(\n    lView: LView, index: number, context: HydrationContext): Array<number>|null {\n  if (!context.isI18nHydrationEnabled) {\n    return null;\n  }\n\n  const tView = lView[TVIEW];\n  const tI18n = tView.data[index] as TI18n | undefined;\n  if (!tI18n || !tI18n.ast) {\n    return null;\n  }\n\n  const caseQueue: number[] = [];\n  tI18n.ast.forEach(node => serializeI18nBlock(lView, caseQueue, context, node));\n  return caseQueue.length > 0 ? caseQueue : null;\n}\n\nfunction serializeI18nBlock(\n    lView: LView, caseQueue: number[], context: HydrationContext, node: I18nNode) {\n  switch (node.kind) {\n    case I18nNodeKind.TEXT:\n      const rNode = unwrapRNode(lView[node.index]!);\n      processTextNodeBeforeSerialization(context, rNode);\n      break;\n\n    case I18nNodeKind.ELEMENT:\n    case I18nNodeKind.PLACEHOLDER:\n      node.children.forEach(node => serializeI18nBlock(lView, caseQueue, context, node));\n      break;\n\n    case I18nNodeKind.ICU:\n      const currentCase = lView[node.currentCaseLViewIndex] as number | null;\n      if (currentCase != null) {\n        // i18n uses a negative value to signal a change to a new case, so we\n        // need to invert it to get the proper value.\n        const caseIdx = currentCase < 0 ? ~currentCase : currentCase;\n        caseQueue.push(caseIdx);\n        node.cases[caseIdx].forEach(node => serializeI18nBlock(lView, caseQueue, context, node));\n      }\n      break;\n  }\n}\n\n/**\n * Describes shared data available during the hydration process.\n */\ninterface I18nHydrationContext {\n  hydrationInfo: DehydratedView;\n  lView: LView;\n  i18nNodes: Map<number, RNode|null>;\n  disconnectedNodes: Set<number>;\n  caseQueue: number[];\n  dehydratedIcuData: Map<number, DehydratedIcuData>;\n}\n\n/**\n * Describes current hydration state.\n */\ninterface I18nHydrationState {\n  // The current node\n  currentNode: Node|null;\n\n  /**\n   * Whether the tree should be connected.\n   *\n   * During hydration, it can happen that we expect to have a\n   * current RNode, but we don't. In such cases, we still need\n   * to propagate the expectation to the corresponding LViews,\n   * so that the proper downstream error handling can provide\n   * the correct context for the error.\n   */\n  isConnected: boolean;\n}\n\nfunction setCurrentNode(state: I18nHydrationState, node: Node|null) {\n  state.currentNode = node;\n}\n\n/**\n * Marks the current RNode as the hydration root for the given\n * AST node.\n */\nfunction appendI18nNodeToCollection(\n    context: I18nHydrationContext, state: I18nHydrationState, astNode: I18nNode) {\n  const noOffsetIndex = astNode.index - HEADER_OFFSET;\n  const {disconnectedNodes} = context;\n  const currentNode = state.currentNode;\n\n  if (state.isConnected) {\n    context.i18nNodes.set(noOffsetIndex, currentNode);\n\n    // We expect the node to be connected, so ensure that it\n    // is not in the set, regardless of whether we found it,\n    // so that the downstream error handling can provide the\n    // proper context.\n    disconnectedNodes.delete(noOffsetIndex);\n  } else {\n    disconnectedNodes.add(noOffsetIndex);\n  }\n\n  return currentNode;\n}\n\n/**\n * Skip over some sibling nodes during hydration.\n *\n * Note: we use this instead of `siblingAfter` as it's expected that\n * sometimes we might encounter null nodes. In those cases, we want to\n * defer to downstream error handling to provide proper context.\n */\nfunction skipSiblingNodes(state: I18nHydrationState, skip: number) {\n  let currentNode = state.currentNode;\n  for (let i = 0; i < skip; i++) {\n    if (!currentNode) {\n      break;\n    }\n    currentNode = currentNode?.nextSibling ?? null;\n  }\n  return currentNode;\n}\n\n/**\n * Fork the given state into a new state for hydrating children.\n */\nfunction forkHydrationState(state: I18nHydrationState, nextNode: Node|null) {\n  return {currentNode: nextNode, isConnected: state.isConnected};\n}\n\nfunction prepareI18nBlockForHydrationImpl(\n    lView: LView, index: number, parentTNode: TNode|null, subTemplateIndex: number) {\n  if (!isI18nHydrationSupportEnabled()) {\n    return;\n  }\n\n  const hydrationInfo = lView[HYDRATION];\n  if (!hydrationInfo) {\n    return;\n  }\n\n  const tView = lView[TVIEW];\n  const tI18n = tView.data[index] as TI18n;\n  ngDevMode &&\n      assertDefined(\n          tI18n, 'Expected i18n data to be present in a given TView slot during hydration');\n\n  function findHydrationRoot() {\n    if (isRootTemplateMessage(subTemplateIndex)) {\n      // This is the root of an i18n block. In this case, our hydration root will\n      // depend on where our parent TNode (i.e. the block with i18n applied) is\n      // in the DOM.\n      ngDevMode && assertDefined(parentTNode, 'Expected parent TNode while hydrating i18n root');\n      const rootNode = locateNextRNode(hydrationInfo!, tView, lView, parentTNode!) as Node;\n\n      // If this i18n block is attached to an <ng-container>, then we want to begin\n      // hydrating directly with the RNode. Otherwise, for a TNode with a physical DOM\n      // element, we want to recurse into the first child and begin there.\n      return (parentTNode!.type & TNodeType.ElementContainer) ? rootNode : rootNode.firstChild;\n    }\n\n    // This is a nested template in an i18n block. In this case, the entire view\n    // is translated, and part of a dehydrated view in a container. This means that\n    // we can simply begin hydration with the first dehydrated child.\n    return hydrationInfo?.firstChild as Node;\n  }\n\n  const currentNode = findHydrationRoot();\n  ngDevMode && assertDefined(currentNode, 'Expected root i18n node during hydration');\n\n  const disconnectedNodes = initDisconnectedNodes(hydrationInfo) ?? new Set();\n  const i18nNodes = hydrationInfo.i18nNodes ??= new Map<number, RNode|null>();\n  const caseQueue = hydrationInfo.data[I18N_DATA]?.[index - HEADER_OFFSET] ?? [];\n  const dehydratedIcuData = hydrationInfo.dehydratedIcuData ??=\n      new Map<number, DehydratedIcuData>();\n\n  collectI18nNodesFromDom(\n      {hydrationInfo, lView, i18nNodes, disconnectedNodes, caseQueue, dehydratedIcuData},\n      {currentNode, isConnected: true}, tI18n.ast);\n\n  // Nodes from inactive ICU cases should be considered disconnected. We track them above\n  // because they aren't (and shouldn't be) serialized. Since we may mutate or create a\n  // new set, we need to be sure to write the expected value back to the DehydratedView.\n  hydrationInfo.disconnectedNodes = disconnectedNodes.size === 0 ? null : disconnectedNodes;\n}\n\nfunction collectI18nNodesFromDom(\n    context: I18nHydrationContext, state: I18nHydrationState, nodeOrNodes: I18nNode|I18nNode[]) {\n  if (Array.isArray(nodeOrNodes)) {\n    for (const node of nodeOrNodes) {\n      // If the node is being projected elsewhere, we need to temporarily\n      // branch the state to that location to continue hydration.\n      // Otherwise, we continue hydration from the current location.\n      const targetNode =\n          tryLocateRNodeByPath(context.hydrationInfo, context.lView, node.index - HEADER_OFFSET);\n      const nextState = targetNode ? forkHydrationState(state, targetNode as Node) : state;\n      collectI18nNodesFromDom(context, nextState, node);\n    }\n  } else {\n    switch (nodeOrNodes.kind) {\n      case I18nNodeKind.TEXT: {\n        // Claim a text node for hydration\n        const currentNode = appendI18nNodeToCollection(context, state, nodeOrNodes);\n        setCurrentNode(state, currentNode?.nextSibling ?? null);\n        break;\n      }\n\n      case I18nNodeKind.ELEMENT: {\n        // Recurse into the current element's children...\n        collectI18nNodesFromDom(\n            context, forkHydrationState(state, state.currentNode?.firstChild ?? null),\n            nodeOrNodes.children);\n\n        // And claim the parent element itself.\n        const currentNode = appendI18nNodeToCollection(context, state, nodeOrNodes);\n        setCurrentNode(state, currentNode?.nextSibling ?? null);\n        break;\n      }\n\n      case I18nNodeKind.PLACEHOLDER: {\n        const noOffsetIndex = nodeOrNodes.index - HEADER_OFFSET;\n        const {hydrationInfo} = context;\n        const containerSize = getNgContainerSize(hydrationInfo, noOffsetIndex);\n\n        switch (nodeOrNodes.type) {\n          case I18nPlaceholderType.ELEMENT: {\n            // Hydration expects to find the head of the element.\n            const currentNode = appendI18nNodeToCollection(context, state, nodeOrNodes);\n\n            // A TNode for the node may not yet if we're hydrating during the first pass,\n            // so use the serialized data to determine if this is an <ng-container>.\n            if (isSerializedElementContainer(hydrationInfo, noOffsetIndex)) {\n              // An <ng-container> doesn't have a physical DOM node, so we need to\n              // continue hydrating from siblings.\n              collectI18nNodesFromDom(context, state, nodeOrNodes.children);\n\n              // Skip over the anchor element. It will be claimed by the\n              // downstream container hydration.\n              const nextNode = skipSiblingNodes(state, 1);\n              setCurrentNode(state, nextNode);\n            } else {\n              // Non-container elements represent an actual node in the DOM, so we\n              // need to continue hydration with the children, and claim the node.\n              collectI18nNodesFromDom(\n                  context, forkHydrationState(state, state.currentNode?.firstChild ?? null),\n                  nodeOrNodes.children);\n              setCurrentNode(state, currentNode?.nextSibling ?? null);\n\n              // Elements can also be the anchor of a view container, so there may\n              // be elements after this node that we need to skip.\n              if (containerSize !== null) {\n                // `+1` stands for an anchor node after all of the views in the container.\n                const nextNode = skipSiblingNodes(state, containerSize + 1);\n                setCurrentNode(state, nextNode);\n              }\n            }\n            break;\n          }\n\n          case I18nPlaceholderType.SUBTEMPLATE: {\n            ngDevMode &&\n                assertNotEqual(\n                    containerSize, null,\n                    'Expected a container size while hydrating i18n subtemplate');\n\n            // Hydration expects to find the head of the template.\n            appendI18nNodeToCollection(context, state, nodeOrNodes);\n\n            // Skip over all of the template children, as well as the anchor\n            // node, since the template itself will handle them instead.\n            const nextNode = skipSiblingNodes(state, containerSize! + 1);\n            setCurrentNode(state, nextNode);\n            break;\n          }\n        }\n        break;\n      }\n\n      case I18nNodeKind.ICU: {\n        // If the current node is connected, we need to pop the next case from the\n        // queue, so that the active case is also considered connected.\n        const selectedCase = state.isConnected ? context.caseQueue.shift()! : null;\n        const childState = {currentNode: null, isConnected: false};\n\n        // We traverse through each case, even if it's not active,\n        // so that we correctly populate disconnected nodes.\n        for (let i = 0; i < nodeOrNodes.cases.length; i++) {\n          collectI18nNodesFromDom(\n              context, i === selectedCase ? state : childState, nodeOrNodes.cases[i]);\n        }\n\n        if (selectedCase !== null) {\n          // ICUs represent a branching state, and the selected case could be different\n          // than what it was on the server. In that case, we need to be able to clean\n          // up the nodes from the original case. To do that, we store the selected case.\n          context.dehydratedIcuData.set(nodeOrNodes.index, {case: selectedCase, node: nodeOrNodes});\n        }\n\n        // Hydration expects to find the ICU anchor element.\n        const currentNode = appendI18nNodeToCollection(context, state, nodeOrNodes);\n        setCurrentNode(state, currentNode?.nextSibling ?? null);\n        break;\n      }\n    }\n  }\n}\n\nlet _claimDehydratedIcuCaseImpl: typeof claimDehydratedIcuCaseImpl = () => {\n  // noop unless `enableClaimDehydratedIcuCaseImpl` is invoked\n};\n\n/**\n * Mark the case for the ICU node at the given index in the view as claimed,\n * allowing its nodes to be hydrated and not cleaned up.\n */\nexport function claimDehydratedIcuCase(lView: LView, icuIndex: number, caseIndex: number) {\n  _claimDehydratedIcuCaseImpl(lView, icuIndex, caseIndex);\n}\n\nexport function enableClaimDehydratedIcuCaseImpl() {\n  _claimDehydratedIcuCaseImpl = claimDehydratedIcuCaseImpl;\n}\n\nfunction claimDehydratedIcuCaseImpl(lView: LView, icuIndex: number, caseIndex: number) {\n  const dehydratedIcuDataMap = lView[HYDRATION]?.dehydratedIcuData;\n  if (dehydratedIcuDataMap) {\n    const dehydratedIcuData = dehydratedIcuDataMap.get(icuIndex);\n    if (dehydratedIcuData?.case === caseIndex) {\n      // If the case we're attempting to claim matches the dehydrated one,\n      // we remove it from the map to mark it as \"claimed.\"\n      dehydratedIcuDataMap.delete(icuIndex);\n    }\n  }\n}\n\n/**\n * Clean up all i18n hydration data associated with the given view.\n */\nexport function cleanupI18nHydrationData(lView: LView) {\n  const hydrationInfo = lView[HYDRATION];\n  if (hydrationInfo) {\n    const {i18nNodes, dehydratedIcuData: dehydratedIcuDataMap} = hydrationInfo;\n    if (i18nNodes && dehydratedIcuDataMap) {\n      const renderer = lView[RENDERER];\n      for (const dehydratedIcuData of dehydratedIcuDataMap.values()) {\n        cleanupDehydratedIcuData(renderer, i18nNodes, dehydratedIcuData);\n      }\n    }\n\n    hydrationInfo.i18nNodes = undefined;\n    hydrationInfo.dehydratedIcuData = undefined;\n  }\n}\n\nfunction cleanupDehydratedIcuData(\n    renderer: Renderer, i18nNodes: Map<number, RNode|null>, dehydratedIcuData: DehydratedIcuData) {\n  for (const node of dehydratedIcuData.node.cases[dehydratedIcuData.case]) {\n    const rNode = i18nNodes.get(node.index - HEADER_OFFSET);\n    if (rNode) {\n      nativeRemoveNode(renderer, rNode, false);\n    }\n  }\n}\n"]}

package/esm2022/src/hydration/interfaces.mjs

@@ -30,4 +30,5 @@ export const NUM_ROOT_NODES = 'r';
 export const TEMPLATE_ID = 'i'; // as it's also an "id"
 export const NODES = 'n';
 export const DISCONNECTED_NODES = 'd';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/hydration/interfaces.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,sFAAsF;AACtF,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAG,CAAC;AAEvC,6EAA6E;AAC7E,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAG,CAAC;AAEvC;;;GAGG;AACH,MAAM,CAAN,IAAY,kBAGX;AAHD,WAAY,kBAAkB;IAC5B,sCAAgB,CAAA;IAChB,uCAAiB,CAAA;AACnB,CAAC,EAHW,kBAAkB,KAAlB,kBAAkB,QAG7B;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAAG,CAAC;AACtC,MAAM,CAAC,MAAM,SAAS,GAAG,GAAG,CAAC;AAC7B,MAAM,CAAC,MAAM,UAAU,GAAG,GAAG,CAAC;AAC9B,MAAM,CAAC,MAAM,UAAU,GAAG,GAAG,CAAC;AAC9B,MAAM,CAAC,MAAM,cAAc,GAAG,GAAG,CAAC;AAClC,MAAM,CAAC,MAAM,WAAW,GAAG,GAAG,CAAC,CAAE,uBAAuB;AACxD,MAAM,CAAC,MAAM,KAAK,GAAG,GAAG,CAAC;AACzB,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAAG,CAAC","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 {RNode} from '../render3/interfaces/renderer_dom';\n\n\n/** Encodes that the node lookup should start from the host node of this component. */\nexport const REFERENCE_NODE_HOST = 'h';\n\n/** Encodes that the node lookup should start from the document body node. */\nexport const REFERENCE_NODE_BODY = 'b';\n\n/**\n * Describes navigation steps that the runtime logic need to perform,\n * starting from a given (known) element.\n */\nexport enum NodeNavigationStep {\n  FirstChild = 'f',\n  NextSibling = 'n',\n}\n\n/**\n * Keys within serialized view data structure to represent various\n * parts. See the `SerializedView` interface below for additional information.\n */\nexport const ELEMENT_CONTAINERS = 'e';\nexport const TEMPLATES = 't';\nexport const CONTAINERS = 'c';\nexport const MULTIPLIER = 'x';\nexport const NUM_ROOT_NODES = 'r';\nexport const TEMPLATE_ID = 'i';  // as it's also an \"id\"\nexport const NODES = 'n';\nexport const DISCONNECTED_NODES = 'd';\n\n/**\n * Represents element containers within this view, stored as key-value pairs\n * where key is an index of a container in an LView (also used in the\n * `elementContainerStart` instruction), the value is the number of root nodes\n * in this container. This information is needed to locate an anchor comment\n * node that goes after all container nodes.\n */\nexport interface SerializedElementContainers {\n  [key: number]: number;\n}\n\n/**\n * Serialized data structure that contains relevant hydration\n * annotation information that describes a given hydration boundary\n * (e.g. a component).\n */\nexport interface SerializedView {\n  /**\n   * Serialized information about <ng-container>s.\n   */\n  [ELEMENT_CONTAINERS]?: SerializedElementContainers;\n\n  /**\n   * Serialized information about templates.\n   * Key-value pairs where a key is an index of the corresponding\n   * `template` instruction and the value is a unique id that can\n   * be used during hydration to identify that template.\n   */\n  [TEMPLATES]?: Record<number, string>;\n\n  /**\n   * Serialized information about view containers.\n   * Key-value pairs where a key is an index of the corresponding\n   * LContainer entry within an LView, and the value is a list\n   * of serialized information about views within this container.\n   */\n  [CONTAINERS]?: Record<number, SerializedContainerView[]>;\n\n  /**\n   * Serialized information about nodes in a template.\n   * Key-value pairs where a key is an index of the corresponding\n   * DOM node in an LView and the value is a path that describes\n   * the location of this node (as a set of navigation instructions).\n   */\n  [NODES]?: Record<number, string>;\n\n  /**\n   * A list of ids which represents a set of nodes disconnected\n   * from the DOM tree at the serialization time, but otherwise\n   * present in the internal data structures.\n   *\n   * This information is used to avoid triggering the hydration\n   * logic for such nodes and instead use a regular \"creation mode\".\n   */\n  [DISCONNECTED_NODES]?: number[];\n}\n\n/**\n * Serialized data structure that contains relevant hydration\n * annotation information about a view that is a part of a\n * ViewContainer collection.\n */\nexport interface SerializedContainerView extends SerializedView {\n  /**\n   * Unique id that represents a TView that was used to create\n   * a given instance of a view:\n   *  - TViewType.Embedded: a unique id generated during serialization on the server\n   *  - TViewType.Component: an id generated based on component properties\n   *                        (see `getComponentId` function for details)\n   */\n  [TEMPLATE_ID]: string;\n\n  /**\n   * Number of root nodes that belong to this view.\n   * This information is needed to effectively traverse the DOM tree\n   * and identify segments that belong to different views.\n   */\n  [NUM_ROOT_NODES]: number;\n\n  /**\n   * Number of times this view is repeated.\n   * This is used to avoid serializing and sending the same hydration\n   * information about similar views (for example, produced by *ngFor).\n   */\n  [MULTIPLIER]?: number;\n}\n\n/**\n * An object that contains hydration-related information serialized\n * on the server, as well as the necessary references to segments of\n * the DOM, to facilitate the hydration process for a given hydration\n * boundary on the client.\n */\nexport interface DehydratedView {\n  /**\n   * The readonly hydration annotation data.\n   */\n  data: Readonly<SerializedView>;\n\n  /**\n   * A reference to the first child in a DOM segment associated\n   * with a given hydration boundary.\n   *\n   * Once a view becomes hydrated, the value is set to `null`, which\n   * indicates that further detaching/attaching view actions should result\n   * in invoking corresponding DOM actions (attaching DOM nodes action is\n   * skipped when we hydrate, since nodes are already in the DOM).\n   */\n  firstChild: RNode|null;\n\n  /**\n   * Stores references to first nodes in DOM segments that\n   * represent either an <ng-container> or a view container.\n   */\n  segmentHeads?: {[index: number]: RNode|null};\n\n  /**\n   * An instance of a Set that represents nodes disconnected from\n   * the DOM tree at the serialization time, but otherwise present\n   * in the internal data structures.\n   *\n   * The Set is based on the `SerializedView[DISCONNECTED_NODES]` data\n   * and is needed to have constant-time lookups.\n   *\n   * If the value is `null`, it means that there were no disconnected\n   * nodes detected in this view at serialization time.\n   */\n  disconnectedNodes?: Set<number>|null;\n\n  /**\n   * A mapping from a view to the first child to begin claiming nodes.\n   *\n   * This mapping is generated by an i18n block, and is the source of\n   * truth for the nodes inside of it. Once a view has been hydrated,\n   * the node is removed from the map. The remaining entries indicate\n   * dehydrated nodes that need to be cleaned up.\n   */\n  i18nNodes?: Map<number, RNode>;\n}\n\n/**\n * An object that contains hydration-related information serialized\n * on the server, as well as the necessary references to segments of\n * the DOM, to facilitate the hydration process for a given view\n * inside a view container (either an embedded view or a view created\n * for a component).\n */\nexport interface DehydratedContainerView extends DehydratedView {\n  data: Readonly<SerializedContainerView>;\n}\n"]}
+export const I18N_DATA = 'l';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/hydration/interfaces.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,sFAAsF;AACtF,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAG,CAAC;AAEvC,6EAA6E;AAC7E,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAG,CAAC;AAEvC;;;GAGG;AACH,MAAM,CAAN,IAAY,kBAGX;AAHD,WAAY,kBAAkB;IAC5B,sCAAgB,CAAA;IAChB,uCAAiB,CAAA;AACnB,CAAC,EAHW,kBAAkB,KAAlB,kBAAkB,QAG7B;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAAG,CAAC;AACtC,MAAM,CAAC,MAAM,SAAS,GAAG,GAAG,CAAC;AAC7B,MAAM,CAAC,MAAM,UAAU,GAAG,GAAG,CAAC;AAC9B,MAAM,CAAC,MAAM,UAAU,GAAG,GAAG,CAAC;AAC9B,MAAM,CAAC,MAAM,cAAc,GAAG,GAAG,CAAC;AAClC,MAAM,CAAC,MAAM,WAAW,GAAG,GAAG,CAAC,CAAE,uBAAuB;AACxD,MAAM,CAAC,MAAM,KAAK,GAAG,GAAG,CAAC;AACzB,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAAG,CAAC;AACtC,MAAM,CAAC,MAAM,SAAS,GAAG,GAAG,CAAC","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 {I18nICUNode} from '../render3/interfaces/i18n';\nimport {RNode} from '../render3/interfaces/renderer_dom';\n\n\n/** Encodes that the node lookup should start from the host node of this component. */\nexport const REFERENCE_NODE_HOST = 'h';\n\n/** Encodes that the node lookup should start from the document body node. */\nexport const REFERENCE_NODE_BODY = 'b';\n\n/**\n * Describes navigation steps that the runtime logic need to perform,\n * starting from a given (known) element.\n */\nexport enum NodeNavigationStep {\n  FirstChild = 'f',\n  NextSibling = 'n',\n}\n\n/**\n * Keys within serialized view data structure to represent various\n * parts. See the `SerializedView` interface below for additional information.\n */\nexport const ELEMENT_CONTAINERS = 'e';\nexport const TEMPLATES = 't';\nexport const CONTAINERS = 'c';\nexport const MULTIPLIER = 'x';\nexport const NUM_ROOT_NODES = 'r';\nexport const TEMPLATE_ID = 'i';  // as it's also an \"id\"\nexport const NODES = 'n';\nexport const DISCONNECTED_NODES = 'd';\nexport const I18N_DATA = 'l';\n\n/**\n * Represents element containers within this view, stored as key-value pairs\n * where key is an index of a container in an LView (also used in the\n * `elementContainerStart` instruction), the value is the number of root nodes\n * in this container. This information is needed to locate an anchor comment\n * node that goes after all container nodes.\n */\nexport interface SerializedElementContainers {\n  [key: number]: number;\n}\n\n/**\n * Serialized data structure that contains relevant hydration\n * annotation information that describes a given hydration boundary\n * (e.g. a component).\n */\nexport interface SerializedView {\n  /**\n   * Serialized information about <ng-container>s.\n   */\n  [ELEMENT_CONTAINERS]?: SerializedElementContainers;\n\n  /**\n   * Serialized information about templates.\n   * Key-value pairs where a key is an index of the corresponding\n   * `template` instruction and the value is a unique id that can\n   * be used during hydration to identify that template.\n   */\n  [TEMPLATES]?: Record<number, string>;\n\n  /**\n   * Serialized information about view containers.\n   * Key-value pairs where a key is an index of the corresponding\n   * LContainer entry within an LView, and the value is a list\n   * of serialized information about views within this container.\n   */\n  [CONTAINERS]?: Record<number, SerializedContainerView[]>;\n\n  /**\n   * Serialized information about nodes in a template.\n   * Key-value pairs where a key is an index of the corresponding\n   * DOM node in an LView and the value is a path that describes\n   * the location of this node (as a set of navigation instructions).\n   */\n  [NODES]?: Record<number, string>;\n\n  /**\n   * A list of ids which represents a set of nodes disconnected\n   * from the DOM tree at the serialization time, but otherwise\n   * present in the internal data structures.\n   *\n   * This information is used to avoid triggering the hydration\n   * logic for such nodes and instead use a regular \"creation mode\".\n   */\n  [DISCONNECTED_NODES]?: number[];\n\n  /**\n   * Serialized information about i18n blocks in a template.\n   * Key-value pairs where a key is an index of the corresponding\n   * i18n entry within an LView, and the value is a list of\n   * active ICU cases.\n   */\n  [I18N_DATA]?: Record<number, number[]>;\n}\n\n/**\n * Serialized data structure that contains relevant hydration\n * annotation information about a view that is a part of a\n * ViewContainer collection.\n */\nexport interface SerializedContainerView extends SerializedView {\n  /**\n   * Unique id that represents a TView that was used to create\n   * a given instance of a view:\n   *  - TViewType.Embedded: a unique id generated during serialization on the server\n   *  - TViewType.Component: an id generated based on component properties\n   *                        (see `getComponentId` function for details)\n   */\n  [TEMPLATE_ID]: string;\n\n  /**\n   * Number of root nodes that belong to this view.\n   * This information is needed to effectively traverse the DOM tree\n   * and identify segments that belong to different views.\n   */\n  [NUM_ROOT_NODES]: number;\n\n  /**\n   * Number of times this view is repeated.\n   * This is used to avoid serializing and sending the same hydration\n   * information about similar views (for example, produced by *ngFor).\n   */\n  [MULTIPLIER]?: number;\n}\n\n/**\n * An object that contains hydration-related information serialized\n * on the server, as well as the necessary references to segments of\n * the DOM, to facilitate the hydration process for a given hydration\n * boundary on the client.\n */\nexport interface DehydratedView {\n  /**\n   * The readonly hydration annotation data.\n   */\n  data: Readonly<SerializedView>;\n\n  /**\n   * A reference to the first child in a DOM segment associated\n   * with a given hydration boundary.\n   *\n   * Once a view becomes hydrated, the value is set to `null`, which\n   * indicates that further detaching/attaching view actions should result\n   * in invoking corresponding DOM actions (attaching DOM nodes action is\n   * skipped when we hydrate, since nodes are already in the DOM).\n   */\n  firstChild: RNode|null;\n\n  /**\n   * Stores references to first nodes in DOM segments that\n   * represent either an <ng-container> or a view container.\n   */\n  segmentHeads?: {[index: number]: RNode|null};\n\n  /**\n   * An instance of a Set that represents nodes disconnected from\n   * the DOM tree at the serialization time, but otherwise present\n   * in the internal data structures.\n   *\n   * The Set is based on the `SerializedView[DISCONNECTED_NODES]` data\n   * and is needed to have constant-time lookups.\n   *\n   * If the value is `null`, it means that there were no disconnected\n   * nodes detected in this view at serialization time.\n   */\n  disconnectedNodes?: Set<number>|null;\n\n  /**\n   * A mapping from a view to the first child to begin claiming nodes.\n   *\n   * This mapping is generated by an i18n block, and is the source of\n   * truth for the nodes inside of it.\n   */\n  i18nNodes?: Map<number, RNode|null>;\n\n  /**\n   * A mapping from the index of an ICU node to dehydrated data for it.\n   *\n   * This information is used during the hydration process on the client.\n   * ICU cases that were active during server-side rendering will be added\n   * to the map. The hydration logic will \"claim\" matching cases, removing\n   * them from the map. The remaining entries are \"unclaimed\", and will be\n   * removed from the DOM during hydration cleanup.\n   */\n  dehydratedIcuData?: Map<number, DehydratedIcuData>;\n}\n\n/**\n * An object that contains hydration-related information serialized\n * on the server, as well as the necessary references to segments of\n * the DOM, to facilitate the hydration process for a given view\n * inside a view container (either an embedded view or a view created\n * for a component).\n */\nexport interface DehydratedContainerView extends DehydratedView {\n  data: Readonly<SerializedContainerView>;\n}\n\n/**\n * An object that contains information about a dehydrated ICU case,\n * to facilitate cleaning up ICU cases that were active during\n * server-side rendering, but not during hydration.\n */\nexport interface DehydratedIcuData {\n  /**\n   * The case index that this data represents.\n   */\n  case: number;\n\n  /**\n   * A reference back to the AST for the ICU node. This allows the\n   * AST to be used to clean up dehydrated nodes.\n   */\n  node: I18nICUNode;\n}\n"]}