@angular/core 16.0.0-next.4 → 16.0.0-next.6

package/esm2022/src/hydration/annotate.mjs

@@ -0,0 +1,426 @@
+/**
+ * @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 { collectNativeNodes } from '../render3/collect_native_nodes';
+import { CONTAINER_HEADER_OFFSET } from '../render3/interfaces/container';
+import { isComponentHost, isLContainer, isProjectionTNode, isRootView } from '../render3/interfaces/type_checks';
+import { HEADER_OFFSET, HOST, RENDERER, TVIEW } from '../render3/interfaces/view';
+import { unwrapRNode } from '../render3/util/view_utils';
+import { TransferState } from '../transfer_state';
+import { notYetSupportedI18nBlockError, unsupportedProjectionOfDomNodes } from './error_handling';
+import { CONTAINERS, DISCONNECTED_NODES, ELEMENT_CONTAINERS, MULTIPLIER, NODES, NUM_ROOT_NODES, TEMPLATE_ID, TEMPLATES } from './interfaces';
+import { calcPathForNode } from './node_lookup_utils';
+import { isInSkipHydrationBlock, SKIP_HYDRATION_ATTR_NAME } from './skip_hydration';
+import { getComponentLViewForHydration, NGH_ATTR_NAME, NGH_DATA_KEY } from './utils';
+/**
+ * A collection that tracks all serialized views (`ngh` DOM annotations)
+ * to avoid duplication. An attempt to add a duplicate view results in the
+ * collection returning the index of the previously collected serialized view.
+ * This reduces the number of annotations needed for a given page.
+ */
+class SerializedViewCollection {
+    constructor() {
+        this.views = [];
+        this.indexByContent = new Map();
+    }
+    add(serializedView) {
+        const viewAsString = JSON.stringify(serializedView);
+        if (!this.indexByContent.has(viewAsString)) {
+            const index = this.views.length;
+            this.views.push(serializedView);
+            this.indexByContent.set(viewAsString, index);
+            return index;
+        }
+        return this.indexByContent.get(viewAsString);
+    }
+    getAll() {
+        return this.views;
+    }
+}
+/**
+ * Global counter that is used to generate a unique id for TViews
+ * during the serialization process.
+ */
+let tViewSsrId = 0;
+/**
+ * Generates a unique id for a given TView and returns this id.
+ * The id is also stored on this instance of a TView and reused in
+ * subsequent calls.
+ *
+ * This id is needed to uniquely identify and pick up dehydrated views
+ * at runtime.
+ */
+function getSsrId(tView) {
+    if (!tView.ssrId) {
+        tView.ssrId = `t${tViewSsrId++}`;
+    }
+    return tView.ssrId;
+}
+/**
+ * Computes the number of root nodes in a given view
+ * (or child nodes in a given container if a tNode is provided).
+ */
+function calcNumRootNodes(tView, lView, tNode) {
+    const rootNodes = [];
+    collectNativeNodes(tView, lView, tNode, rootNodes);
+    return rootNodes.length;
+}
+/**
+ * Annotates all components bootstrapped in a given ApplicationRef
+ * with info needed for hydration.
+ *
+ * @param appRef An instance of an ApplicationRef.
+ * @param doc A reference to the current Document instance.
+ */
+export function annotateForHydration(appRef, doc) {
+    const serializedViewCollection = new SerializedViewCollection();
+    const corruptedTextNodes = new Map();
+    const viewRefs = appRef._views;
+    for (const viewRef of viewRefs) {
+        const lView = getComponentLViewForHydration(viewRef);
+        // An `lView` might be `null` if a `ViewRef` represents
+        // an embedded view (not a component view).
+        if (lView !== null) {
+            const hostElement = lView[HOST];
+            if (hostElement) {
+                const context = {
+                    serializedViewCollection,
+                    corruptedTextNodes,
+                };
+                annotateHostElementForHydration(hostElement, lView, context);
+                insertCorruptedTextNodeMarkers(corruptedTextNodes, doc);
+            }
+        }
+    }
+    const allSerializedViews = serializedViewCollection.getAll();
+    if (allSerializedViews.length > 0) {
+        const transferState = appRef.injector.get(TransferState);
+        transferState.set(NGH_DATA_KEY, allSerializedViews);
+    }
+}
+/**
+ * Serializes the lContainer data into a list of SerializedView objects,
+ * that represent views within this lContainer.
+ *
+ * @param lContainer the lContainer we are serializing
+ * @param context the hydration context
+ * @returns an array of the `SerializedView` objects
+ */
+function serializeLContainer(lContainer, context) {
+    const views = [];
+    let lastViewAsString = '';
+    for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
+        let childLView = lContainer[i];
+        // If this is a root view, get an LView for the underlying component,
+        // because it contains information about the view to serialize.
+        if (isRootView(childLView)) {
+            childLView = childLView[HEADER_OFFSET];
+        }
+        const childTView = childLView[TVIEW];
+        let template;
+        let numRootNodes = 0;
+        if (childTView.type === 1 /* TViewType.Component */) {
+            template = childTView.ssrId;
+            // This is a component view, thus it has only 1 root node: the component
+            // host node itself (other nodes would be inside that host node).
+            numRootNodes = 1;
+        }
+        else {
+            template = getSsrId(childTView);
+            numRootNodes = calcNumRootNodes(childTView, childLView, childTView.firstChild);
+        }
+        const view = {
+            [TEMPLATE_ID]: template,
+            [NUM_ROOT_NODES]: numRootNodes,
+            ...serializeLView(lContainer[i], context),
+        };
+        // Check if the previous view has the same shape (for example, it was
+        // produced by the *ngFor), in which case bump the counter on the previous
+        // view instead of including the same information again.
+        const currentViewAsString = JSON.stringify(view);
+        if (views.length > 0 && currentViewAsString === lastViewAsString) {
+            const previousView = views[views.length - 1];
+            previousView[MULTIPLIER] ??= 1;
+            previousView[MULTIPLIER]++;
+        }
+        else {
+            // Record this view as most recently added.
+            lastViewAsString = currentViewAsString;
+            views.push(view);
+        }
+    }
+    return views;
+}
+/**
+ * Helper function to produce a node path (which navigation steps runtime logic
+ * needs to take to locate a node) and stores it in the `NODES` section of the
+ * current serialized view.
+ */
+function appendSerializedNodePath(ngh, tNode, lView) {
+    const noOffsetIndex = tNode.index - HEADER_OFFSET;
+    ngh[NODES] ??= {};
+    ngh[NODES][noOffsetIndex] = calcPathForNode(tNode, lView);
+}
+/**
+ * Helper function to append information about a disconnected node.
+ * This info is needed at runtime to avoid DOM lookups for this element
+ * and instead, the element would be created from scratch.
+ */
+function appendDisconnectedNodeIndex(ngh, tNode) {
+    const noOffsetIndex = tNode.index - HEADER_OFFSET;
+    ngh[DISCONNECTED_NODES] ??= [];
+    if (!ngh[DISCONNECTED_NODES].includes(noOffsetIndex)) {
+        ngh[DISCONNECTED_NODES].push(noOffsetIndex);
+    }
+}
+/**
+ * There is no special TNode type for an i18n block, so we verify
+ * whether the structure that we store at the `TView.data[idx]` position
+ * has the `TI18n` shape.
+ */
+function isTI18nNode(obj) {
+    const tI18n = obj;
+    return tI18n.hasOwnProperty('create') && tI18n.hasOwnProperty('update');
+}
+/**
+ * Serializes the lView data into a SerializedView object that will later be added
+ * to the TransferState storage and referenced using the `ngh` attribute on a host
+ * element.
+ *
+ * @param lView the lView we are serializing
+ * @param context the hydration context
+ * @returns the `SerializedView` object containing the data to be added to the host node
+ */
+function serializeLView(lView, context) {
+    const ngh = {};
+    const tView = lView[TVIEW];
+    // Iterate over DOM element references in an LView.
+    for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {
+        const tNode = tView.data[i];
+        const noOffsetIndex = i - HEADER_OFFSET;
+        // Local refs (e.g. <div #localRef>) take up an extra slot in LViews
+        // to store the same element. In this case, there is no information in
+        // a corresponding slot in TNode data structure. If that's the case, just
+        // skip this slot and move to the next one.
+        if (!tNode) {
+            continue;
+        }
+        // Check if a native node that represents a given TNode is disconnected from the DOM tree.
+        // Such nodes must be excluded from the hydration (since the hydration won't be able to
+        // find them), so the TNode ids are collected and used at runtime to skip the hydration.
+        //
+        // This situation may happen during the content projection, when some nodes don't make it
+        // into one of the content projection slots (for example, when there is no default
+        // <ng-content /> slot in projector component's template).
+        if (isDisconnectedNode(tNode, lView) && isContentProjectedNode(tNode)) {
+            appendDisconnectedNodeIndex(ngh, tNode);
+            continue;
+        }
+        if (Array.isArray(tNode.projection)) {
+            for (const projectionHeadTNode of tNode.projection) {
+                // We may have `null`s in slots with no projected content.
+                if (!projectionHeadTNode)
+                    continue;
+                if (!Array.isArray(projectionHeadTNode)) {
+                    // If we process re-projected content (i.e. `<ng-content>`
+                    // appears at projection location), skip annotations for this content
+                    // since all DOM nodes in this projection were handled while processing
+                    // a parent lView, which contains those nodes.
+                    if (!isProjectionTNode(projectionHeadTNode) &&
+                        !isInSkipHydrationBlock(projectionHeadTNode)) {
+                        if (isDisconnectedNode(projectionHeadTNode, lView)) {
+                            // Check whether this node is connected, since we may have a TNode
+                            // in the data structure as a projection segment head, but the
+                            // content projection slot might be disabled (e.g.
+                            // <ng-content *ngIf="false" />).
+                            appendDisconnectedNodeIndex(ngh, projectionHeadTNode);
+                        }
+                        else {
+                            appendSerializedNodePath(ngh, projectionHeadTNode, lView);
+                        }
+                    }
+                }
+                else {
+                    // If a value is an array, it means that we are processing a projection
+                    // where projectable nodes were passed in as DOM nodes (for example, when
+                    // calling `ViewContainerRef.createComponent(CmpA, {projectableNodes: [...]})`).
+                    //
+                    // In this scenario, nodes can come from anywhere (either created manually,
+                    // accessed via `document.querySelector`, etc) and may be in any state
+                    // (attached or detached from the DOM tree). As a result, we can not reliably
+                    // restore the state for such cases during hydration.
+                    throw unsupportedProjectionOfDomNodes(unwrapRNode(lView[i]));
+                }
+            }
+        }
+        if (isLContainer(lView[i])) {
+            // Serialize information about a template.
+            const embeddedTView = tNode.tView;
+            if (embeddedTView !== null) {
+                ngh[TEMPLATES] ??= {};
+                ngh[TEMPLATES][noOffsetIndex] = getSsrId(embeddedTView);
+            }
+            // Serialize views within this LContainer.
+            const hostNode = lView[i][HOST]; // host node of this container
+            // LView[i][HOST] can be of 2 different types:
+            // - either a DOM node
+            // - or an array that represents an LView of a component
+            if (Array.isArray(hostNode)) {
+                // This is a component, serialize info about it.
+                const targetNode = unwrapRNode(hostNode);
+                if (!targetNode.hasAttribute(SKIP_HYDRATION_ATTR_NAME)) {
+                    annotateHostElementForHydration(targetNode, hostNode, context);
+                }
+            }
+            ngh[CONTAINERS] ??= {};
+            ngh[CONTAINERS][noOffsetIndex] = serializeLContainer(lView[i], context);
+        }
+        else if (Array.isArray(lView[i])) {
+            // This is a component, annotate the host node with an `ngh` attribute.
+            const targetNode = unwrapRNode(lView[i][HOST]);
+            if (!targetNode.hasAttribute(SKIP_HYDRATION_ATTR_NAME)) {
+                annotateHostElementForHydration(targetNode, lView[i], context);
+            }
+        }
+        else if (isTI18nNode(tNode)) {
+            // Hydration for i18n nodes is not *yet* supported.
+            // Produce an error message which would also describe possible
+            // solutions (switching back to the "destructive" hydration or
+            // excluding a component from hydration via `ngSkipHydration`).
+            //
+            // TODO(akushnir): we should find a better way to get a hold of the node that has the `i18n`
+            // attribute on it. For now, we either refer to the host element of the component or to the
+            // previous element in the LView.
+            const targetNode = (i === HEADER_OFFSET) ? lView[HOST] : unwrapRNode(lView[i - 1]);
+            throw notYetSupportedI18nBlockError(targetNode);
+        }
+        else {
+            // <ng-container> case
+            if (tNode.type & 8 /* TNodeType.ElementContainer */) {
+                // An <ng-container> is represented by the number of
+                // top-level nodes. This information is needed to skip over
+                // those nodes to reach a corresponding anchor node (comment node).
+                ngh[ELEMENT_CONTAINERS] ??= {};
+                ngh[ELEMENT_CONTAINERS][noOffsetIndex] = calcNumRootNodes(tView, lView, tNode.child);
+            }
+            else if (tNode.type & 16 /* TNodeType.Projection */) {
+                // Current TNode represents an `<ng-content>` slot, thus it has no
+                // DOM elements associated with it, so the **next sibling** node would
+                // not be able to find an anchor. In this case, use full path instead.
+                let nextTNode = tNode.next;
+                // Skip over all `<ng-content>` slots in a row.
+                while (nextTNode !== null && (nextTNode.type & 16 /* TNodeType.Projection */)) {
+                    nextTNode = nextTNode.next;
+                }
+                if (nextTNode && !isInSkipHydrationBlock(nextTNode)) {
+                    // Handle a tNode after the `<ng-content>` slot.
+                    appendSerializedNodePath(ngh, nextTNode, lView);
+                }
+            }
+            else {
+                // Handle cases where text nodes can be lost after DOM serialization:
+                //  1. When there is an *empty text node* in DOM: in this case, this
+                //     node would not make it into the serialized string and as a result,
+                //     this node wouldn't be created in a browser. This would result in
+                //     a mismatch during the hydration, where the runtime logic would expect
+                //     a text node to be present in live DOM, but no text node would exist.
+                //     Example: `<span>{{ name }}</span>` when the `name` is an empty string.
+                //     This would result in `<span></span>` string after serialization and
+                //     in a browser only the `span` element would be created. To resolve that,
+                //     an extra comment node is appended in place of an empty text node and
+                //     that special comment node is replaced with an empty text node *before*
+                //     hydration.
+                //  2. When there are 2 consecutive text nodes present in the DOM.
+                //     Example: `<div>Hello <ng-container *ngIf="true">world</ng-container></div>`.
+                //     In this scenario, the live DOM would look like this:
+                //       <div>#text('Hello ') #text('world') #comment('container')</div>
+                //     Serialized string would look like this: `<div>Hello world<!--container--></div>`.
+                //     The live DOM in a browser after that would be:
+                //       <div>#text('Hello world') #comment('container')</div>
+                //     Notice how 2 text nodes are now "merged" into one. This would cause hydration
+                //     logic to fail, since it'd expect 2 text nodes being present, not one.
+                //     To fix this, we insert a special comment node in between those text nodes, so
+                //     serialized representation is: `<div>Hello <!--ngtns-->world<!--container--></div>`.
+                //     This forces browser to create 2 text nodes separated by a comment node.
+                //     Before running a hydration process, this special comment node is removed, so the
+                //     live DOM has exactly the same state as it was before serialization.
+                if (tNode.type & 1 /* TNodeType.Text */) {
+                    const rNode = unwrapRNode(lView[i]);
+                    if (rNode.textContent?.replace(/\s/gm, '') === '') {
+                        context.corruptedTextNodes.set(rNode, "ngetn" /* TextNodeMarker.EmptyNode */);
+                    }
+                    else if (rNode.nextSibling?.nodeType === Node.TEXT_NODE) {
+                        context.corruptedTextNodes.set(rNode, "ngtns" /* TextNodeMarker.Separator */);
+                    }
+                }
+                if (tNode.projectionNext && tNode.projectionNext !== tNode.next &&
+                    !isInSkipHydrationBlock(tNode.projectionNext)) {
+                    // Check if projection next is not the same as next, in which case
+                    // the node would not be found at creation time at runtime and we
+                    // need to provide a location for that node.
+                    appendSerializedNodePath(ngh, tNode.projectionNext, lView);
+                }
+            }
+        }
+    }
+    return ngh;
+}
+/**
+ * Physically adds the `ngh` attribute and serialized data to the host element.
+ *
+ * @param element The Host element to be annotated
+ * @param lView The associated LView
+ * @param context The hydration context
+ */
+function annotateHostElementForHydration(element, lView, context) {
+    const ngh = serializeLView(lView, context);
+    const index = context.serializedViewCollection.add(ngh);
+    const renderer = lView[RENDERER];
+    renderer.setAttribute(element, NGH_ATTR_NAME, index.toString());
+}
+/**
+ * Physically inserts the comment nodes to ensure empty text nodes and adjacent
+ * text node separators are preserved after server serialization of the DOM.
+ * These get swapped back for empty text nodes or separators once hydration happens
+ * on the client.
+ *
+ * @param corruptedTextNodes The Map of text nodes to be replaced with comments
+ * @param doc The document
+ */
+function insertCorruptedTextNodeMarkers(corruptedTextNodes, doc) {
+    for (const [textNode, marker] of corruptedTextNodes) {
+        textNode.after(doc.createComment(marker));
+    }
+}
+/**
+ * Detects whether a given TNode represents a node that
+ * is being content projected.
+ */
+function isContentProjectedNode(tNode) {
+    let currentTNode = tNode;
+    while (currentTNode != null) {
+        // If we come across a component host node in parent nodes -
+        // this TNode is in the content projection section.
+        if (isComponentHost(currentTNode)) {
+            return true;
+        }
+        currentTNode = currentTNode.parent;
+    }
+    return false;
+}
+/**
+ * Check whether a given node exists, but is disconnected from the DOM.
+ *
+ * Note: we leverage the fact that we have this information available in the DOM emulation
+ * layer (in Domino) for now. Longer-term solution should not rely on the DOM emulation and
+ * only use internal data structures and state to compute this information.
+ */
+function isDisconnectedNode(tNode, lView) {
+    return !(tNode.type & 16 /* TNodeType.Projection */) && !!lView[tNode.index] &&
+        !unwrapRNode(lView[tNode.index]).isConnected;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"annotate.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/hydration/annotate.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 {ApplicationRef} from '../application_ref';\nimport {collectNativeNodes} from '../render3/collect_native_nodes';\nimport {CONTAINER_HEADER_OFFSET, LContainer} from '../render3/interfaces/container';\nimport {TI18n} from '../render3/interfaces/i18n';\nimport {TNode, TNodeType} from '../render3/interfaces/node';\nimport {RElement} from '../render3/interfaces/renderer_dom';\nimport {isComponentHost, isLContainer, isProjectionTNode, isRootView} from '../render3/interfaces/type_checks';\nimport {HEADER_OFFSET, HOST, LView, RENDERER, TView, TVIEW, TViewType} from '../render3/interfaces/view';\nimport {unwrapRNode} from '../render3/util/view_utils';\nimport {TransferState} from '../transfer_state';\n\nimport {notYetSupportedI18nBlockError, unsupportedProjectionOfDomNodes} from './error_handling';\nimport {CONTAINERS, DISCONNECTED_NODES, ELEMENT_CONTAINERS, MULTIPLIER, NODES, NUM_ROOT_NODES, SerializedContainerView, SerializedView, TEMPLATE_ID, TEMPLATES} from './interfaces';\nimport {calcPathForNode} from './node_lookup_utils';\nimport {isInSkipHydrationBlock, SKIP_HYDRATION_ATTR_NAME} from './skip_hydration';\nimport {getComponentLViewForHydration, NGH_ATTR_NAME, NGH_DATA_KEY, TextNodeMarker} from './utils';\n\n/**\n * A collection that tracks all serialized views (`ngh` DOM annotations)\n * to avoid duplication. An attempt to add a duplicate view results in the\n * collection returning the index of the previously collected serialized view.\n * This reduces the number of annotations needed for a given page.\n */\nclass SerializedViewCollection {\n  private views: SerializedView[] = [];\n  private indexByContent = new Map<string, number>();\n\n  add(serializedView: SerializedView): number {\n    const viewAsString = JSON.stringify(serializedView);\n    if (!this.indexByContent.has(viewAsString)) {\n      const index = this.views.length;\n      this.views.push(serializedView);\n      this.indexByContent.set(viewAsString, index);\n      return index;\n    }\n    return this.indexByContent.get(viewAsString)!;\n  }\n\n  getAll(): SerializedView[] {\n    return this.views;\n  }\n}\n\n/**\n * Global counter that is used to generate a unique id for TViews\n * during the serialization process.\n */\nlet tViewSsrId = 0;\n\n/**\n * Generates a unique id for a given TView and returns this id.\n * The id is also stored on this instance of a TView and reused in\n * subsequent calls.\n *\n * This id is needed to uniquely identify and pick up dehydrated views\n * at runtime.\n */\nfunction getSsrId(tView: TView): string {\n  if (!tView.ssrId) {\n    tView.ssrId = `t${tViewSsrId++}`;\n  }\n  return tView.ssrId;\n}\n\n/**\n * Describes a context available during the serialization\n * process. The context is used to share and collect information\n * during the serialization.\n */\ninterface HydrationContext {\n  serializedViewCollection: SerializedViewCollection;\n  corruptedTextNodes: Map<HTMLElement, TextNodeMarker>;\n}\n\n/**\n * Computes the number of root nodes in a given view\n * (or child nodes in a given container if a tNode is provided).\n */\nfunction calcNumRootNodes(tView: TView, lView: LView, tNode: TNode|null): number {\n  const rootNodes: unknown[] = [];\n  collectNativeNodes(tView, lView, tNode, rootNodes);\n  return rootNodes.length;\n}\n\n/**\n * Annotates all components bootstrapped in a given ApplicationRef\n * with info needed for hydration.\n *\n * @param appRef An instance of an ApplicationRef.\n * @param doc A reference to the current Document instance.\n */\nexport function annotateForHydration(appRef: ApplicationRef, doc: Document) {\n  const serializedViewCollection = new SerializedViewCollection();\n  const corruptedTextNodes = new Map<HTMLElement, TextNodeMarker>();\n  const viewRefs = appRef._views;\n  for (const viewRef of viewRefs) {\n    const lView = getComponentLViewForHydration(viewRef);\n    // An `lView` might be `null` if a `ViewRef` represents\n    // an embedded view (not a component view).\n    if (lView !== null) {\n      const hostElement = lView[HOST];\n      if (hostElement) {\n        const context: HydrationContext = {\n          serializedViewCollection,\n          corruptedTextNodes,\n        };\n        annotateHostElementForHydration(hostElement as HTMLElement, lView, context);\n        insertCorruptedTextNodeMarkers(corruptedTextNodes, doc);\n      }\n    }\n  }\n  const allSerializedViews = serializedViewCollection.getAll();\n  if (allSerializedViews.length > 0) {\n    const transferState = appRef.injector.get(TransferState);\n    transferState.set(NGH_DATA_KEY, allSerializedViews);\n  }\n}\n\n/**\n * Serializes the lContainer data into a list of SerializedView objects,\n * that represent views within this lContainer.\n *\n * @param lContainer the lContainer we are serializing\n * @param context the hydration context\n * @returns an array of the `SerializedView` objects\n */\nfunction serializeLContainer(\n    lContainer: LContainer, context: HydrationContext): SerializedContainerView[] {\n  const views: SerializedContainerView[] = [];\n  let lastViewAsString: string = '';\n\n  for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {\n    let childLView = lContainer[i] as LView;\n\n    // If this is a root view, get an LView for the underlying component,\n    // because it contains information about the view to serialize.\n    if (isRootView(childLView)) {\n      childLView = childLView[HEADER_OFFSET];\n    }\n    const childTView = childLView[TVIEW];\n\n    let template: string;\n    let numRootNodes = 0;\n    if (childTView.type === TViewType.Component) {\n      template = childTView.ssrId!;\n\n      // This is a component view, thus it has only 1 root node: the component\n      // host node itself (other nodes would be inside that host node).\n      numRootNodes = 1;\n    } else {\n      template = getSsrId(childTView);\n      numRootNodes = calcNumRootNodes(childTView, childLView, childTView.firstChild);\n    }\n\n    const view: SerializedContainerView = {\n      [TEMPLATE_ID]: template,\n      [NUM_ROOT_NODES]: numRootNodes,\n      ...serializeLView(lContainer[i] as LView, context),\n    };\n\n    // Check if the previous view has the same shape (for example, it was\n    // produced by the *ngFor), in which case bump the counter on the previous\n    // view instead of including the same information again.\n    const currentViewAsString = JSON.stringify(view);\n    if (views.length > 0 && currentViewAsString === lastViewAsString) {\n      const previousView = views[views.length - 1];\n      previousView[MULTIPLIER] ??= 1;\n      previousView[MULTIPLIER]++;\n    } else {\n      // Record this view as most recently added.\n      lastViewAsString = currentViewAsString;\n      views.push(view);\n    }\n  }\n  return views;\n}\n\n/**\n * Helper function to produce a node path (which navigation steps runtime logic\n * needs to take to locate a node) and stores it in the `NODES` section of the\n * current serialized view.\n */\nfunction appendSerializedNodePath(ngh: SerializedView, tNode: TNode, lView: LView) {\n  const noOffsetIndex = tNode.index - HEADER_OFFSET;\n  ngh[NODES] ??= {};\n  ngh[NODES][noOffsetIndex] = calcPathForNode(tNode, lView);\n}\n\n/**\n * Helper function to append information about a disconnected node.\n * This info is needed at runtime to avoid DOM lookups for this element\n * and instead, the element would be created from scratch.\n */\nfunction appendDisconnectedNodeIndex(ngh: SerializedView, tNode: TNode) {\n  const noOffsetIndex = tNode.index - HEADER_OFFSET;\n  ngh[DISCONNECTED_NODES] ??= [];\n  if (!ngh[DISCONNECTED_NODES].includes(noOffsetIndex)) {\n    ngh[DISCONNECTED_NODES].push(noOffsetIndex);\n  }\n}\n\n/**\n * There is no special TNode type for an i18n block, so we verify\n * whether the structure that we store at the `TView.data[idx]` position\n * has the `TI18n` shape.\n */\nfunction isTI18nNode(obj: unknown): boolean {\n  const tI18n = obj as TI18n;\n  return tI18n.hasOwnProperty('create') && tI18n.hasOwnProperty('update');\n}\n\n/**\n * Serializes the lView data into a SerializedView object that will later be added\n * to the TransferState storage and referenced using the `ngh` attribute on a host\n * element.\n *\n * @param lView the lView we are serializing\n * @param context the hydration context\n * @returns the `SerializedView` object containing the data to be added to the host node\n */\nfunction serializeLView(lView: LView, context: HydrationContext): SerializedView {\n  const ngh: SerializedView = {};\n  const tView = lView[TVIEW];\n  // Iterate over DOM element references in an LView.\n  for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {\n    const tNode = tView.data[i] as TNode;\n    const noOffsetIndex = i - HEADER_OFFSET;\n    // Local refs (e.g. <div #localRef>) take up an extra slot in LViews\n    // to store the same element. In this case, there is no information in\n    // a corresponding slot in TNode data structure. If that's the case, just\n    // skip this slot and move to the next one.\n    if (!tNode) {\n      continue;\n    }\n\n    // Check if a native node that represents a given TNode is disconnected from the DOM tree.\n    // Such nodes must be excluded from the hydration (since the hydration won't be able to\n    // find them), so the TNode ids are collected and used at runtime to skip the hydration.\n    //\n    // This situation may happen during the content projection, when some nodes don't make it\n    // into one of the content projection slots (for example, when there is no default\n    // <ng-content /> slot in projector component's template).\n    if (isDisconnectedNode(tNode, lView) && isContentProjectedNode(tNode)) {\n      appendDisconnectedNodeIndex(ngh, tNode);\n      continue;\n    }\n    if (Array.isArray(tNode.projection)) {\n      for (const projectionHeadTNode of tNode.projection) {\n        // We may have `null`s in slots with no projected content.\n        if (!projectionHeadTNode) continue;\n\n        if (!Array.isArray(projectionHeadTNode)) {\n          // If we process re-projected content (i.e. `<ng-content>`\n          // appears at projection location), skip annotations for this content\n          // since all DOM nodes in this projection were handled while processing\n          // a parent lView, which contains those nodes.\n          if (!isProjectionTNode(projectionHeadTNode) &&\n              !isInSkipHydrationBlock(projectionHeadTNode)) {\n            if (isDisconnectedNode(projectionHeadTNode, lView)) {\n              // Check whether this node is connected, since we may have a TNode\n              // in the data structure as a projection segment head, but the\n              // content projection slot might be disabled (e.g.\n              // <ng-content *ngIf=\"false\" />).\n              appendDisconnectedNodeIndex(ngh, projectionHeadTNode);\n            } else {\n              appendSerializedNodePath(ngh, projectionHeadTNode, lView);\n            }\n          }\n        } else {\n          // If a value is an array, it means that we are processing a projection\n          // where projectable nodes were passed in as DOM nodes (for example, when\n          // calling `ViewContainerRef.createComponent(CmpA, {projectableNodes: [...]})`).\n          //\n          // In this scenario, nodes can come from anywhere (either created manually,\n          // accessed via `document.querySelector`, etc) and may be in any state\n          // (attached or detached from the DOM tree). As a result, we can not reliably\n          // restore the state for such cases during hydration.\n\n          throw unsupportedProjectionOfDomNodes(unwrapRNode(lView[i]));\n        }\n      }\n    }\n    if (isLContainer(lView[i])) {\n      // Serialize information about a template.\n      const embeddedTView = tNode.tView;\n      if (embeddedTView !== null) {\n        ngh[TEMPLATES] ??= {};\n        ngh[TEMPLATES][noOffsetIndex] = getSsrId(embeddedTView);\n      }\n\n      // Serialize views within this LContainer.\n      const hostNode = lView[i][HOST]!;  // host node of this container\n\n      // LView[i][HOST] can be of 2 different types:\n      // - either a DOM node\n      // - or an array that represents an LView of a component\n      if (Array.isArray(hostNode)) {\n        // This is a component, serialize info about it.\n        const targetNode = unwrapRNode(hostNode as LView) as RElement;\n        if (!(targetNode as HTMLElement).hasAttribute(SKIP_HYDRATION_ATTR_NAME)) {\n          annotateHostElementForHydration(targetNode, hostNode as LView, context);\n        }\n      }\n      ngh[CONTAINERS] ??= {};\n      ngh[CONTAINERS][noOffsetIndex] = serializeLContainer(lView[i], context);\n    } else if (Array.isArray(lView[i])) {\n      // This is a component, annotate the host node with an `ngh` attribute.\n      const targetNode = unwrapRNode(lView[i][HOST]!);\n      if (!(targetNode as HTMLElement).hasAttribute(SKIP_HYDRATION_ATTR_NAME)) {\n        annotateHostElementForHydration(targetNode as RElement, lView[i], context);\n      }\n    } else if (isTI18nNode(tNode)) {\n      // Hydration for i18n nodes is not *yet* supported.\n      // Produce an error message which would also describe possible\n      // solutions (switching back to the \"destructive\" hydration or\n      // excluding a component from hydration via `ngSkipHydration`).\n      //\n      // TODO(akushnir): we should find a better way to get a hold of the node that has the `i18n`\n      // attribute on it. For now, we either refer to the host element of the component or to the\n      // previous element in the LView.\n      const targetNode = (i === HEADER_OFFSET) ? lView[HOST]! : unwrapRNode(lView[i - 1]);\n      throw notYetSupportedI18nBlockError(targetNode);\n    } else {\n      // <ng-container> case\n      if (tNode.type & TNodeType.ElementContainer) {\n        // An <ng-container> is represented by the number of\n        // top-level nodes. This information is needed to skip over\n        // those nodes to reach a corresponding anchor node (comment node).\n        ngh[ELEMENT_CONTAINERS] ??= {};\n        ngh[ELEMENT_CONTAINERS][noOffsetIndex] = calcNumRootNodes(tView, lView, tNode.child);\n      } else if (tNode.type & TNodeType.Projection) {\n        // Current TNode represents an `<ng-content>` slot, thus it has no\n        // DOM elements associated with it, so the **next sibling** node would\n        // not be able to find an anchor. In this case, use full path instead.\n        let nextTNode = tNode.next;\n        // Skip over all `<ng-content>` slots in a row.\n        while (nextTNode !== null && (nextTNode.type & TNodeType.Projection)) {\n          nextTNode = nextTNode.next;\n        }\n        if (nextTNode && !isInSkipHydrationBlock(nextTNode)) {\n          // Handle a tNode after the `<ng-content>` slot.\n          appendSerializedNodePath(ngh, nextTNode, lView);\n        }\n      } else {\n        // Handle cases where text nodes can be lost after DOM serialization:\n        //  1. When there is an *empty text node* in DOM: in this case, this\n        //     node would not make it into the serialized string and as a result,\n        //     this node wouldn't be created in a browser. This would result in\n        //     a mismatch during the hydration, where the runtime logic would expect\n        //     a text node to be present in live DOM, but no text node would exist.\n        //     Example: `<span>{{ name }}</span>` when the `name` is an empty string.\n        //     This would result in `<span></span>` string after serialization and\n        //     in a browser only the `span` element would be created. To resolve that,\n        //     an extra comment node is appended in place of an empty text node and\n        //     that special comment node is replaced with an empty text node *before*\n        //     hydration.\n        //  2. When there are 2 consecutive text nodes present in the DOM.\n        //     Example: `<div>Hello <ng-container *ngIf=\"true\">world</ng-container></div>`.\n        //     In this scenario, the live DOM would look like this:\n        //       <div>#text('Hello ') #text('world') #comment('container')</div>\n        //     Serialized string would look like this: `<div>Hello world<!--container--></div>`.\n        //     The live DOM in a browser after that would be:\n        //       <div>#text('Hello world') #comment('container')</div>\n        //     Notice how 2 text nodes are now \"merged\" into one. This would cause hydration\n        //     logic to fail, since it'd expect 2 text nodes being present, not one.\n        //     To fix this, we insert a special comment node in between those text nodes, so\n        //     serialized representation is: `<div>Hello <!--ngtns-->world<!--container--></div>`.\n        //     This forces browser to create 2 text nodes separated by a comment node.\n        //     Before running a hydration process, this special comment node is removed, so the\n        //     live DOM has exactly the same state as it was before serialization.\n        if (tNode.type & TNodeType.Text) {\n          const rNode = unwrapRNode(lView[i]) as HTMLElement;\n          if (rNode.textContent?.replace(/\\s/gm, '') === '') {\n            context.corruptedTextNodes.set(rNode, TextNodeMarker.EmptyNode);\n          } else if (rNode.nextSibling?.nodeType === Node.TEXT_NODE) {\n            context.corruptedTextNodes.set(rNode, TextNodeMarker.Separator);\n          }\n        }\n\n        if (tNode.projectionNext && tNode.projectionNext !== tNode.next &&\n            !isInSkipHydrationBlock(tNode.projectionNext)) {\n          // Check if projection next is not the same as next, in which case\n          // the node would not be found at creation time at runtime and we\n          // need to provide a location for that node.\n          appendSerializedNodePath(ngh, tNode.projectionNext, lView);\n        }\n      }\n    }\n  }\n  return ngh;\n}\n\n/**\n * Physically adds the `ngh` attribute and serialized data to the host element.\n *\n * @param element The Host element to be annotated\n * @param lView The associated LView\n * @param context The hydration context\n */\nfunction annotateHostElementForHydration(\n    element: RElement, lView: LView, context: HydrationContext): void {\n  const ngh = serializeLView(lView, context);\n  const index = context.serializedViewCollection.add(ngh);\n  const renderer = lView[RENDERER];\n  renderer.setAttribute(element, NGH_ATTR_NAME, index.toString());\n}\n\n/**\n * Physically inserts the comment nodes to ensure empty text nodes and adjacent\n * text node separators are preserved after server serialization of the DOM.\n * These get swapped back for empty text nodes or separators once hydration happens\n * on the client.\n *\n * @param corruptedTextNodes The Map of text nodes to be replaced with comments\n * @param doc The document\n */\nfunction insertCorruptedTextNodeMarkers(\n    corruptedTextNodes: Map<HTMLElement, string>, doc: Document) {\n  for (const [textNode, marker] of corruptedTextNodes) {\n    textNode.after(doc.createComment(marker));\n  }\n}\n\n/**\n * Detects whether a given TNode represents a node that\n * is being content projected.\n */\nfunction isContentProjectedNode(tNode: TNode): boolean {\n  let currentTNode = tNode;\n  while (currentTNode != null) {\n    // If we come across a component host node in parent nodes -\n    // this TNode is in the content projection section.\n    if (isComponentHost(currentTNode)) {\n      return true;\n    }\n    currentTNode = currentTNode.parent as TNode;\n  }\n  return false;\n}\n\n/**\n * Check whether a given node exists, but is disconnected from the DOM.\n *\n * Note: we leverage the fact that we have this information available in the DOM emulation\n * layer (in Domino) for now. Longer-term solution should not rely on the DOM emulation and\n * only use internal data structures and state to compute this information.\n */\nfunction isDisconnectedNode(tNode: TNode, lView: LView) {\n  return !(tNode.type & TNodeType.Projection) && !!lView[tNode.index] &&\n      !(unwrapRNode(lView[tNode.index]) as Node).isConnected;\n}\n"]}