@angular/core 16.0.0-next.1 → 16.0.0-next.3

package/esm2020/src/hydration/annotate.mjs

@@ -0,0 +1,271 @@
+/**
+ * @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 { isLContainer, 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 { CONTAINERS, ELEMENT_CONTAINERS, NUM_ROOT_NODES, TEMPLATE_ID, TEMPLATES } from './interfaces';
+import { 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 = [];
+    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),
+        };
+        views.push(view);
+    }
+    return views;
+}
+/**
+ * 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;
+        }
+        if (isLContainer(lView[i])) {
+            // Serialize information about a template.
+            const embeddedTView = tNode.tView;
+            if (embeddedTView !== null) {
+                ngh[TEMPLATES] ?? (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] = {});
+            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 {
+            // <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] = {});
+                ngh[ELEMENT_CONTAINERS][noOffsetIndex] = calcNumRootNodes(tView, lView, tNode.child);
+            }
+            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 */);
+                    }
+                }
+            }
+        }
+    }
+    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));
+    }
+}
+//# 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 {TNode, TNodeType} from '../render3/interfaces/node';\nimport {RElement} from '../render3/interfaces/renderer_dom';\nimport {isLContainer, 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 {CONTAINERS, ELEMENT_CONTAINERS, NUM_ROOT_NODES, SerializedContainerView, SerializedView, TEMPLATE_ID, TEMPLATES} from './interfaces';\nimport {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\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    views.push(view);\n  }\n  return views;\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    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 {\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 {\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    }\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"]}

package/esm2020/src/hydration/api.mjs

@@ -0,0 +1,128 @@
+/**
+ * @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 { PLATFORM_ID } from '../application_tokens';
+import { ENVIRONMENT_INITIALIZER, makeEnvironmentProviders } from '../di';
+import { inject } from '../di/injector_compatibility';
+import { enableLocateOrCreateContainerRefImpl } from '../linker/view_container_ref';
+import { enableLocateOrCreateElementNodeImpl } from '../render3/instructions/element';
+import { enableLocateOrCreateElementContainerNodeImpl } from '../render3/instructions/element_container';
+import { enableApplyRootElementTransformImpl } from '../render3/instructions/shared';
+import { enableLocateOrCreateContainerAnchorImpl } from '../render3/instructions/template';
+import { enableLocateOrCreateTextNodeImpl } from '../render3/instructions/text';
+import { IS_HYDRATION_FEATURE_ENABLED, PRESERVE_HOST_CONTENT } from './tokens';
+import { enableRetrieveHydrationInfoImpl } from './utils';
+import { enableFindMatchingDehydratedViewImpl } from './views';
+/**
+ * Indicates whether the hydration-related code was added,
+ * prevents adding it multiple times.
+ */
+let isHydrationSupportEnabled = false;
+/**
+ * Brings the necessary hydration code in tree-shakable manner.
+ * The code is only present when the `provideHydrationSupport` is
+ * invoked. Otherwise, this code is tree-shaken away during the
+ * build optimization step.
+ *
+ * This technique allows us to swap implementations of methods so
+ * tree shaking works appropriately when hydration is disabled or
+ * enabled. It brings in the appropriate version of the method that
+ * supports hydration only when enabled.
+ */
+function enableHydrationRuntimeSupport() {
+    if (!isHydrationSupportEnabled) {
+        isHydrationSupportEnabled = true;
+        enableRetrieveHydrationInfoImpl();
+        enableLocateOrCreateElementNodeImpl();
+        enableLocateOrCreateTextNodeImpl();
+        enableLocateOrCreateElementContainerNodeImpl();
+        enableLocateOrCreateContainerAnchorImpl();
+        enableLocateOrCreateContainerRefImpl();
+        enableFindMatchingDehydratedViewImpl();
+        enableApplyRootElementTransformImpl();
+    }
+}
+/**
+ * Detects whether the code is invoked in a browser.
+ * Later on, this check should be replaced with a tree-shakable
+ * flag (e.g. `!isServer`).
+ */
+function isBrowser() {
+    return inject(PLATFORM_ID) === 'browser';
+}
+/**
+ * Returns a set of providers required to setup hydration support
+ * for an application that is server side rendered.
+ *
+ * ## NgModule-based bootstrap
+ *
+ * You can add the function call to the root AppModule of an application:
+ * ```
+ * import {provideHydrationSupport} from '@angular/core';
+ *
+ * @NgModule({
+ *   providers: [
+ *     // ... other providers ...
+ *     provideHydrationSupport()
+ *   ],
+ *   declarations: [AppComponent],
+ *   bootstrap: [AppComponent]
+ * })
+ * class AppModule {}
+ * ```
+ *
+ * ## Standalone-based bootstrap
+ *
+ * Add the function to the `bootstrapApplication` call:
+ * ```
+ * import {provideHydrationSupport} from '@angular/core';
+ *
+ * bootstrapApplication(RootComponent, {
+ *   providers: [
+ *     // ... other providers ...
+ *     provideHydrationSupport()
+ *   ]
+ * });
+ * ```
+ *
+ * The function sets up an internal flag that would be recognized during
+ * the server side rendering time as well, so there is no need to
+ * configure or change anything in NgUniversal to enable the feature.
+ *
+ * @publicApi
+ * @developerPreview
+ */
+export function provideHydrationSupport() {
+    return makeEnvironmentProviders([
+        {
+            provide: ENVIRONMENT_INITIALIZER,
+            useValue: () => {
+                // Since this function is used across both server and client,
+                // make sure that the runtime code is only added when invoked
+                // on the client. Moving forward, the `isBrowser` check should
+                // be replaced with a tree-shakable alternative (e.g. `isServer`
+                // flag).
+                if (isBrowser()) {
+                    enableHydrationRuntimeSupport();
+                }
+            },
+            multi: true,
+        },
+        {
+            provide: IS_HYDRATION_FEATURE_ENABLED,
+            useValue: true,
+        },
+        {
+            provide: PRESERVE_HOST_CONTENT,
+            // Preserve host element content only in a browser
+            // environment. On a server, an application is rendered
+            // from scratch, so the host content needs to be empty.
+            useFactory: () => isBrowser(),
+        }
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/hydration/api.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,WAAW,EAAC,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAC,uBAAuB,EAAwB,wBAAwB,EAAC,MAAM,OAAO,CAAC;AAC9F,OAAO,EAAC,MAAM,EAAC,MAAM,8BAA8B,CAAC;AACpD,OAAO,EAAC,oCAAoC,EAAC,MAAM,8BAA8B,CAAC;AAClF,OAAO,EAAC,mCAAmC,EAAC,MAAM,iCAAiC,CAAC;AACpF,OAAO,EAAC,4CAA4C,EAAC,MAAM,2CAA2C,CAAC;AACvG,OAAO,EAAC,mCAAmC,EAAC,MAAM,gCAAgC,CAAC;AACnF,OAAO,EAAC,uCAAuC,EAAC,MAAM,kCAAkC,CAAC;AACzF,OAAO,EAAC,gCAAgC,EAAC,MAAM,8BAA8B,CAAC;AAE9E,OAAO,EAAC,4BAA4B,EAAE,qBAAqB,EAAC,MAAM,UAAU,CAAC;AAC7E,OAAO,EAAC,+BAA+B,EAAC,MAAM,SAAS,CAAC;AACxD,OAAO,EAAC,oCAAoC,EAAC,MAAM,SAAS,CAAC;AAG7D;;;GAGG;AACH,IAAI,yBAAyB,GAAG,KAAK,CAAC;AAEtC;;;;;;;;;;GAUG;AACH,SAAS,6BAA6B;IACpC,IAAI,CAAC,yBAAyB,EAAE;QAC9B,yBAAyB,GAAG,IAAI,CAAC;QACjC,+BAA+B,EAAE,CAAC;QAClC,mCAAmC,EAAE,CAAC;QACtC,gCAAgC,EAAE,CAAC;QACnC,4CAA4C,EAAE,CAAC;QAC/C,uCAAuC,EAAE,CAAC;QAC1C,oCAAoC,EAAE,CAAC;QACvC,oCAAoC,EAAE,CAAC;QACvC,mCAAmC,EAAE,CAAC;KACvC;AACH,CAAC;AAED;;;;GAIG;AACH,SAAS,SAAS;IAChB,OAAO,MAAM,CAAC,WAAW,CAAC,KAAK,SAAS,CAAC;AAC3C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAM,UAAU,uBAAuB;IACrC,OAAO,wBAAwB,CAAC;QAC9B;YACE,OAAO,EAAE,uBAAuB;YAChC,QAAQ,EAAE,GAAG,EAAE;gBACb,6DAA6D;gBAC7D,6DAA6D;gBAC7D,8DAA8D;gBAC9D,gEAAgE;gBAChE,SAAS;gBACT,IAAI,SAAS,EAAE,EAAE;oBACf,6BAA6B,EAAE,CAAC;iBACjC;YACH,CAAC;YACD,KAAK,EAAE,IAAI;SACZ;QACD;YACE,OAAO,EAAE,4BAA4B;YACrC,QAAQ,EAAE,IAAI;SACf;QACD;YACE,OAAO,EAAE,qBAAqB;YAC9B,kDAAkD;YAClD,uDAAuD;YACvD,uDAAuD;YACvD,UAAU,EAAE,GAAG,EAAE,CAAC,SAAS,EAAE;SAC9B;KACF,CAAC,CAAC;AACL,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 {PLATFORM_ID} from '../application_tokens';\nimport {ENVIRONMENT_INITIALIZER, EnvironmentProviders, makeEnvironmentProviders} from '../di';\nimport {inject} from '../di/injector_compatibility';\nimport {enableLocateOrCreateContainerRefImpl} from '../linker/view_container_ref';\nimport {enableLocateOrCreateElementNodeImpl} from '../render3/instructions/element';\nimport {enableLocateOrCreateElementContainerNodeImpl} from '../render3/instructions/element_container';\nimport {enableApplyRootElementTransformImpl} from '../render3/instructions/shared';\nimport {enableLocateOrCreateContainerAnchorImpl} from '../render3/instructions/template';\nimport {enableLocateOrCreateTextNodeImpl} from '../render3/instructions/text';\n\nimport {IS_HYDRATION_FEATURE_ENABLED, PRESERVE_HOST_CONTENT} from './tokens';\nimport {enableRetrieveHydrationInfoImpl} from './utils';\nimport {enableFindMatchingDehydratedViewImpl} from './views';\n\n\n/**\n * Indicates whether the hydration-related code was added,\n * prevents adding it multiple times.\n */\nlet isHydrationSupportEnabled = false;\n\n/**\n * Brings the necessary hydration code in tree-shakable manner.\n * The code is only present when the `provideHydrationSupport` is\n * invoked. Otherwise, this code is tree-shaken away during the\n * build optimization step.\n *\n * This technique allows us to swap implementations of methods so\n * tree shaking works appropriately when hydration is disabled or\n * enabled. It brings in the appropriate version of the method that\n * supports hydration only when enabled.\n */\nfunction enableHydrationRuntimeSupport() {\n  if (!isHydrationSupportEnabled) {\n    isHydrationSupportEnabled = true;\n    enableRetrieveHydrationInfoImpl();\n    enableLocateOrCreateElementNodeImpl();\n    enableLocateOrCreateTextNodeImpl();\n    enableLocateOrCreateElementContainerNodeImpl();\n    enableLocateOrCreateContainerAnchorImpl();\n    enableLocateOrCreateContainerRefImpl();\n    enableFindMatchingDehydratedViewImpl();\n    enableApplyRootElementTransformImpl();\n  }\n}\n\n/**\n * Detects whether the code is invoked in a browser.\n * Later on, this check should be replaced with a tree-shakable\n * flag (e.g. `!isServer`).\n */\nfunction isBrowser(): boolean {\n  return inject(PLATFORM_ID) === 'browser';\n}\n\n/**\n * Returns a set of providers required to setup hydration support\n * for an application that is server side rendered.\n *\n * ## NgModule-based bootstrap\n *\n * You can add the function call to the root AppModule of an application:\n * ```\n * import {provideHydrationSupport} from '@angular/core';\n *\n * @NgModule({\n *   providers: [\n *     // ... other providers ...\n *     provideHydrationSupport()\n *   ],\n *   declarations: [AppComponent],\n *   bootstrap: [AppComponent]\n * })\n * class AppModule {}\n * ```\n *\n * ## Standalone-based bootstrap\n *\n * Add the function to the `bootstrapApplication` call:\n * ```\n * import {provideHydrationSupport} from '@angular/core';\n *\n * bootstrapApplication(RootComponent, {\n *   providers: [\n *     // ... other providers ...\n *     provideHydrationSupport()\n *   ]\n * });\n * ```\n *\n * The function sets up an internal flag that would be recognized during\n * the server side rendering time as well, so there is no need to\n * configure or change anything in NgUniversal to enable the feature.\n *\n * @publicApi\n * @developerPreview\n */\nexport function provideHydrationSupport(): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    {\n      provide: ENVIRONMENT_INITIALIZER,\n      useValue: () => {\n        // Since this function is used across both server and client,\n        // make sure that the runtime code is only added when invoked\n        // on the client. Moving forward, the `isBrowser` check should\n        // be replaced with a tree-shakable alternative (e.g. `isServer`\n        // flag).\n        if (isBrowser()) {\n          enableHydrationRuntimeSupport();\n        }\n      },\n      multi: true,\n    },\n    {\n      provide: IS_HYDRATION_FEATURE_ENABLED,\n      useValue: true,\n    },\n    {\n      provide: PRESERVE_HOST_CONTENT,\n      // Preserve host element content only in a browser\n      // environment. On a server, an application is rendered\n      // from scratch, so the host content needs to be empty.\n      useFactory: () => isBrowser(),\n    }\n  ]);\n}\n"]}

package/esm2020/src/hydration/cleanup.mjs

@@ -0,0 +1,50 @@
+/**
+ * @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 { DEHYDRATED_VIEWS } from '../render3/interfaces/container';
+import { PARENT, RENDERER } from '../render3/interfaces/view';
+import { nativeRemoveNode } from '../render3/node_manipulation';
+import { EMPTY_ARRAY } from '../util/empty';
+import { validateSiblingNodeExists } from './error_handling';
+import { NUM_ROOT_NODES } from './interfaces';
+/**
+ * Removes all dehydrated views from a given LContainer:
+ * both in internal data structure, as well as removing
+ * corresponding DOM nodes that belong to that dehydrated view.
+ */
+export function removeDehydratedViews(lContainer) {
+    const views = lContainer[DEHYDRATED_VIEWS] ?? [];
+    const parentLView = lContainer[PARENT];
+    const renderer = parentLView[RENDERER];
+    for (const view of views) {
+        removeDehydratedView(view, renderer);
+        ngDevMode && ngDevMode.dehydratedViewsRemoved++;
+    }
+    // Reset the value to an empty array to indicate that no
+    // further processing of dehydrated views is needed for
+    // this view container (i.e. do not trigger the lookup process
+    // once again in case a `ViewContainerRef` is created later).
+    lContainer[DEHYDRATED_VIEWS] = EMPTY_ARRAY;
+}
+/**
+ * Helper function to remove all nodes from a dehydrated view.
+ */
+function removeDehydratedView(dehydratedView, renderer) {
+    let nodesRemoved = 0;
+    let currentRNode = dehydratedView.firstChild;
+    if (currentRNode) {
+        const numNodes = dehydratedView.data[NUM_ROOT_NODES];
+        while (nodesRemoved < numNodes) {
+            ngDevMode && validateSiblingNodeExists(currentRNode);
+            const nextSibling = currentRNode.nextSibling;
+            nativeRemoveNode(renderer, currentRNode, false);
+            currentRNode = nextSibling;
+            nodesRemoved++;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/hydration/error_handling.mjs

@@ -0,0 +1,37 @@
+/**
+ * @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
+ */
+/**
+ * Verifies whether a given node matches an expected criteria,
+ * based on internal data structure state.
+ */
+export function validateMatchingNode(node, nodeType, tagName, lView, tNode) {
+    validateNodeExists(node);
+    if (node.nodeType !== nodeType ||
+        node.nodeType === Node.ELEMENT_NODE &&
+            node.tagName.toLowerCase() !== tagName?.toLowerCase()) {
+        // TODO: improve error message and use RuntimeError instead.
+        throw new Error(`Unexpected node found during hydration.`);
+    }
+}
+/**
+ * Verifies whether next sibling node exists.
+ */
+export function validateSiblingNodeExists(node) {
+    validateNodeExists(node);
+    if (!node.nextSibling) {
+        // TODO: improve error message and use RuntimeError instead.
+        throw new Error(`Unexpected state: insufficient number of sibling nodes.`);
+    }
+}
+export function validateNodeExists(node) {
+    if (!node) {
+        // TODO: improve error message and use RuntimeError instead.
+        throw new Error(`Hydration expected an element to be present at this location.`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/hydration/interfaces.mjs

@@ -0,0 +1,17 @@
+/**
+ * @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
+ */
+/**
+ * Keys within serialized view data structure to represent various
+ * parts. See the `SerializedView` interface below for additional information.
+ */
+export const ELEMENT_CONTAINERS = 'e';
+export const TEMPLATES = 't';
+export const CONTAINERS = 'c';
+export const NUM_ROOT_NODES = 'r';
+export const TEMPLATE_ID = 'i'; // as it's also an "id"
+//# sourceMappingURL=data:application/json;base64,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