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

package/esm2020/src/hydration/utils.mjs

@@ -5,11 +5,12 @@
  * 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 { getDocument } from '../render3/interfaces/document';
 import { isRootView } from '../render3/interfaces/type_checks';
 import { HEADER_OFFSET, TVIEW } from '../render3/interfaces/view';
 import { makeStateKey, TransferState } from '../transfer_state';
 import { assertDefined } from '../util/assert';
-import { ELEMENT_CONTAINERS } from './interfaces';
+import { CONTAINERS, ELEMENT_CONTAINERS, NUM_ROOT_NODES } from './interfaces';
 /**
  * The name of the key used in the TransferState collection,
  * where hydration information is located.
@@ -70,7 +71,7 @@ export function retrieveHydrationInfoImpl(rNode, injector) {
     return dehydratedView;
 }
 /**
- * Sets the implementation for the `retrieveNghInfo` function.
+ * Sets the implementation for the `retrieveHydrationInfo` function.
  */
 export function enableRetrieveHydrationInfoImpl() {
     _retrieveHydrationInfoImpl = retrieveHydrationInfoImpl;
@@ -102,6 +103,46 @@ export function getComponentLViewForHydration(viewRef) {
     }
     return lView;
 }
+function getTextNodeContent(node) {
+    return node.textContent?.replace(/\s/gm, '');
+}
+/**
+ * Restores text nodes and separators into the DOM that were lost during SSR
+ * serialization. The hydration process replaces empty text nodes and text
+ * nodes that are immediately adjacent to other text nodes with comment nodes
+ * that this method filters on to restore those missing nodes that the
+ * hydration process is expecting to be present.
+ *
+ * @param node The app's root HTML Element
+ */
+export function processTextNodeMarkersBeforeHydration(node) {
+    const doc = getDocument();
+    const commentNodesIterator = doc.createNodeIterator(node, NodeFilter.SHOW_COMMENT, {
+        acceptNode(node) {
+            const content = getTextNodeContent(node);
+            const isTextNodeMarker = content === "ngetn" /* TextNodeMarker.EmptyNode */ || content === "ngtns" /* TextNodeMarker.Separator */;
+            return isTextNodeMarker ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+        }
+    });
+    let currentNode;
+    // We cannot modify the DOM while using the commentIterator,
+    // because it throws off the iterator state.
+    // So we collect all marker nodes first and then follow up with
+    // applying the changes to the DOM: either inserting an empty node
+    // or just removing the marker if it was used as a separator.
+    const nodes = [];
+    while (currentNode = commentNodesIterator.nextNode()) {
+        nodes.push(currentNode);
+    }
+    for (const node of nodes) {
+        if (node.textContent === "ngetn" /* TextNodeMarker.EmptyNode */) {
+            node.replaceWith(doc.createTextNode(''));
+        }
+        else {
+            node.remove();
+        }
+    }
+}
 /**
  * Marks a node as "claimed" by hydration process.
  * This is needed to make assessments in tests whether
@@ -121,11 +162,45 @@ export function markRNodeAsClaimedByHydration(node, checkIfAlreadyClaimed = true
 export function isRNodeClaimedForHydration(node) {
     return !!node.__claimed;
 }
-export function storeNgContainerInfo(hydrationInfo, index, firstChild) {
-    hydrationInfo.ngContainers ?? (hydrationInfo.ngContainers = {});
-    hydrationInfo.ngContainers[index] = { firstChild };
+export function setSegmentHead(hydrationInfo, index, node) {
+    hydrationInfo.segmentHeads ?? (hydrationInfo.segmentHeads = {});
+    hydrationInfo.segmentHeads[index] = node;
 }
+export function getSegmentHead(hydrationInfo, index) {
+    return hydrationInfo.segmentHeads?.[index] ?? null;
+}
+/**
+ * Returns the size of an <ng-container>, using either the information
+ * serialized in `ELEMENT_CONTAINERS` (element container size) or by
+ * computing the sum of root nodes in all dehydrated views in a given
+ * container (in case this `<ng-container>` was also used as a view
+ * container host node, e.g. <ng-container *ngIf>).
+ */
 export function getNgContainerSize(hydrationInfo, index) {
-    return hydrationInfo.data[ELEMENT_CONTAINERS]?.[index] ?? null;
+    const data = hydrationInfo.data;
+    let size = data[ELEMENT_CONTAINERS]?.[index] ?? null;
+    // If there is no serialized information available in the `ELEMENT_CONTAINERS` slot,
+    // check if we have info about view containers at this location (e.g.
+    // `<ng-container *ngIf>`) and use container size as a number of root nodes in this
+    // element container.
+    if (size === null && data[CONTAINERS]?.[index]) {
+        size = calcSerializedContainerSize(hydrationInfo, index);
+    }
+    return size;
+}
+export function getSerializedContainerViews(hydrationInfo, index) {
+    return hydrationInfo.data[CONTAINERS]?.[index] ?? null;
+}
+/**
+ * Computes the size of a serialized container (the number of root nodes)
+ * by calculating the sum of root nodes in all dehydrated views in this container.
+ */
+export function calcSerializedContainerSize(hydrationInfo, index) {
+    const views = getSerializedContainerViews(hydrationInfo, index) ?? [];
+    let numNodes = 0;
+    for (let view of views) {
+        numNodes += view[NUM_ROOT_NODES];
+    }
+    return numNodes;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/hydration/utils.ts"],"names":[],"mappings":"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","sourcesContent":["\n/**\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 {Injector} from '../di/injector';\nimport {ViewRef} from '../linker/view_ref';\nimport {RElement, RNode} from '../render3/interfaces/renderer_dom';\nimport {isRootView} from '../render3/interfaces/type_checks';\nimport {HEADER_OFFSET, LView, TVIEW, TViewType} from '../render3/interfaces/view';\nimport {makeStateKey, TransferState} from '../transfer_state';\nimport {assertDefined} from '../util/assert';\n\nimport {DehydratedView, ELEMENT_CONTAINERS, SerializedView} from './interfaces';\n\n/**\n * The name of the key used in the TransferState collection,\n * where hydration information is located.\n */\nconst TRANSFER_STATE_TOKEN_ID = '__ɵnghData__';\n\n/**\n * Lookup key used to reference DOM hydration data (ngh) in `TransferState`.\n */\nexport const NGH_DATA_KEY = makeStateKey<Array<SerializedView>>(TRANSFER_STATE_TOKEN_ID);\n\n/**\n * The name of the attribute that would be added to host component\n * nodes and contain a reference to a particular slot in transferred\n * state that contains the necessary hydration info for this component.\n */\nexport const NGH_ATTR_NAME = 'ngh';\n\n/**\n * Reference to a function that reads `ngh` attribute value from a given RNode\n * and retrieves hydration information from the TransferState using that value\n * as an index. Returns `null` by default, when hydration is not enabled.\n *\n * @param rNode Component's host element.\n * @param injector Injector that this component has access to.\n */\nlet _retrieveHydrationInfoImpl: typeof retrieveHydrationInfoImpl =\n    (rNode: RElement, injector: Injector) => null;\n\nexport function retrieveHydrationInfoImpl(rNode: RElement, injector: Injector): DehydratedView|\n    null {\n  const nghAttrValue = rNode.getAttribute(NGH_ATTR_NAME);\n  if (nghAttrValue == null) return null;\n\n  let data: SerializedView = {};\n  // An element might have an empty `ngh` attribute value (e.g. `<comp ngh=\"\" />`),\n  // which means that no special annotations are required. Do not attempt to read\n  // from the TransferState in this case.\n  if (nghAttrValue !== '') {\n    const transferState = injector.get(TransferState, null, {optional: true});\n    if (transferState !== null) {\n      const nghData = transferState.get(NGH_DATA_KEY, []);\n\n      // The nghAttrValue is always a number referencing an index\n      // in the hydration TransferState data.\n      data = nghData[Number(nghAttrValue)];\n\n      // If the `ngh` attribute exists and has a non-empty value,\n      // the hydration info *must* be present in the TransferState.\n      // If there is no data for some reasons, this is an error.\n      ngDevMode && assertDefined(data, 'Unable to retrieve hydration info from the TransferState.');\n    }\n  }\n  const dehydratedView: DehydratedView = {\n    data,\n    firstChild: rNode.firstChild ?? null,\n  };\n  // The `ngh` attribute is cleared from the DOM node now\n  // that the data has been retrieved.\n  rNode.removeAttribute(NGH_ATTR_NAME);\n\n  // Note: don't check whether this node was claimed for hydration,\n  // because this node might've been previously claimed while processing\n  // template instructions.\n  ngDevMode && markRNodeAsClaimedByHydration(rNode, /* checkIfAlreadyClaimed */ false);\n  ngDevMode && ngDevMode.hydratedComponents++;\n\n  return dehydratedView;\n}\n\n/**\n * Sets the implementation for the `retrieveNghInfo` function.\n */\nexport function enableRetrieveHydrationInfoImpl() {\n  _retrieveHydrationInfoImpl = retrieveHydrationInfoImpl;\n}\n\n/**\n * Retrieves hydration info by reading the value from the `ngh` attribute\n * and accessing a corresponding slot in TransferState storage.\n */\nexport function retrieveHydrationInfo(rNode: RElement, injector: Injector): DehydratedView|null {\n  return _retrieveHydrationInfoImpl(rNode, injector);\n}\n\n/**\n * Retrieves an instance of a component LView from a given ViewRef.\n * Returns an instance of a component LView or `null` in case of an embedded view.\n */\nexport function getComponentLViewForHydration(viewRef: ViewRef): LView|null {\n  // Reading an internal field from `ViewRef` instance.\n  let lView = (viewRef as any)._lView as LView;\n  const tView = lView[TVIEW];\n  // A registered ViewRef might represent an instance of an\n  // embedded view, in which case we do not need to annotate it.\n  if (tView.type === TViewType.Embedded) {\n    return null;\n  }\n  // Check if it's a root view and if so, retrieve component's\n  // LView from the first slot after the header.\n  if (isRootView(lView)) {\n    lView = lView[HEADER_OFFSET];\n  }\n  return lView;\n}\n\n/**\n * Internal type that represents a claimed node.\n * Only used in dev mode.\n */\ntype ClaimedNode = {\n  __claimed?: boolean;\n};\n\n/**\n * Marks a node as \"claimed\" by hydration process.\n * This is needed to make assessments in tests whether\n * the hydration process handled all nodes.\n */\nexport function markRNodeAsClaimedByHydration(node: RNode, checkIfAlreadyClaimed = true) {\n  if (!ngDevMode) {\n    throw new Error(\n        'Calling `markRNodeAsClaimedByHydration` in prod mode ' +\n        'is not supported and likely a mistake.');\n  }\n  if (checkIfAlreadyClaimed && isRNodeClaimedForHydration(node)) {\n    throw new Error('Trying to claim a node, which was claimed already.');\n  }\n  (node as ClaimedNode).__claimed = true;\n  ngDevMode.hydratedNodes++;\n}\n\nexport function isRNodeClaimedForHydration(node: RNode): boolean {\n  return !!(node as ClaimedNode).__claimed;\n}\n\nexport function storeNgContainerInfo(\n    hydrationInfo: DehydratedView, index: number, firstChild: RNode): void {\n  hydrationInfo.ngContainers ??= {};\n  hydrationInfo.ngContainers[index] = {firstChild};\n}\n\nexport function getNgContainerSize(hydrationInfo: DehydratedView, index: number): number|null {\n  return hydrationInfo.data[ELEMENT_CONTAINERS]?.[index] ?? null;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/hydration/utils.ts"],"names":[],"mappings":"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","sourcesContent":["\n/**\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 {Injector} from '../di/injector';\nimport {ViewRef} from '../linker/view_ref';\nimport {getDocument} from '../render3/interfaces/document';\nimport {RElement, RNode} from '../render3/interfaces/renderer_dom';\nimport {isRootView} from '../render3/interfaces/type_checks';\nimport {HEADER_OFFSET, LView, TVIEW, TViewType} from '../render3/interfaces/view';\nimport {makeStateKey, TransferState} from '../transfer_state';\nimport {assertDefined} from '../util/assert';\n\nimport {CONTAINERS, DehydratedView, ELEMENT_CONTAINERS, NUM_ROOT_NODES, SerializedContainerView, SerializedView} from './interfaces';\n\n/**\n * The name of the key used in the TransferState collection,\n * where hydration information is located.\n */\nconst TRANSFER_STATE_TOKEN_ID = '__ɵnghData__';\n\n/**\n * Lookup key used to reference DOM hydration data (ngh) in `TransferState`.\n */\nexport const NGH_DATA_KEY = makeStateKey<Array<SerializedView>>(TRANSFER_STATE_TOKEN_ID);\n\n/**\n * The name of the attribute that would be added to host component\n * nodes and contain a reference to a particular slot in transferred\n * state that contains the necessary hydration info for this component.\n */\nexport const NGH_ATTR_NAME = 'ngh';\n\nexport const enum TextNodeMarker {\n\n  /**\n   * The contents of the text comment added to nodes that would otherwise be\n   * empty when serialized by the server and passed to the client. The empty\n   * node is lost when the browser parses it otherwise. This comment node will\n   * be replaced during hydration in the client to restore the lost empty text\n   * node.\n   */\n  EmptyNode = 'ngetn',\n\n  /**\n   * The contents of the text comment added in the case of adjacent text nodes.\n   * When adjacent text nodes are serialized by the server and sent to the\n   * client, the browser loses reference to the amount of nodes and assumes\n   * just one text node. This separator is replaced during hydration to restore\n   * the proper separation and amount of text nodes that should be present.\n   */\n  Separator = 'ngtns',\n}\n\n/**\n * Reference to a function that reads `ngh` attribute value from a given RNode\n * and retrieves hydration information from the TransferState using that value\n * as an index. Returns `null` by default, when hydration is not enabled.\n *\n * @param rNode Component's host element.\n * @param injector Injector that this component has access to.\n */\nlet _retrieveHydrationInfoImpl: typeof retrieveHydrationInfoImpl =\n    (rNode: RElement, injector: Injector) => null;\n\nexport function retrieveHydrationInfoImpl(rNode: RElement, injector: Injector): DehydratedView|\n    null {\n  const nghAttrValue = rNode.getAttribute(NGH_ATTR_NAME);\n  if (nghAttrValue == null) return null;\n\n  let data: SerializedView = {};\n  // An element might have an empty `ngh` attribute value (e.g. `<comp ngh=\"\" />`),\n  // which means that no special annotations are required. Do not attempt to read\n  // from the TransferState in this case.\n  if (nghAttrValue !== '') {\n    const transferState = injector.get(TransferState, null, {optional: true});\n    if (transferState !== null) {\n      const nghData = transferState.get(NGH_DATA_KEY, []);\n\n      // The nghAttrValue is always a number referencing an index\n      // in the hydration TransferState data.\n      data = nghData[Number(nghAttrValue)];\n\n      // If the `ngh` attribute exists and has a non-empty value,\n      // the hydration info *must* be present in the TransferState.\n      // If there is no data for some reasons, this is an error.\n      ngDevMode && assertDefined(data, 'Unable to retrieve hydration info from the TransferState.');\n    }\n  }\n  const dehydratedView: DehydratedView = {\n    data,\n    firstChild: rNode.firstChild ?? null,\n  };\n  // The `ngh` attribute is cleared from the DOM node now\n  // that the data has been retrieved.\n  rNode.removeAttribute(NGH_ATTR_NAME);\n\n  // Note: don't check whether this node was claimed for hydration,\n  // because this node might've been previously claimed while processing\n  // template instructions.\n  ngDevMode && markRNodeAsClaimedByHydration(rNode, /* checkIfAlreadyClaimed */ false);\n  ngDevMode && ngDevMode.hydratedComponents++;\n\n  return dehydratedView;\n}\n\n/**\n * Sets the implementation for the `retrieveHydrationInfo` function.\n */\nexport function enableRetrieveHydrationInfoImpl() {\n  _retrieveHydrationInfoImpl = retrieveHydrationInfoImpl;\n}\n\n/**\n * Retrieves hydration info by reading the value from the `ngh` attribute\n * and accessing a corresponding slot in TransferState storage.\n */\nexport function retrieveHydrationInfo(rNode: RElement, injector: Injector): DehydratedView|null {\n  return _retrieveHydrationInfoImpl(rNode, injector);\n}\n\n/**\n * Retrieves an instance of a component LView from a given ViewRef.\n * Returns an instance of a component LView or `null` in case of an embedded view.\n */\nexport function getComponentLViewForHydration(viewRef: ViewRef): LView|null {\n  // Reading an internal field from `ViewRef` instance.\n  let lView = (viewRef as any)._lView as LView;\n  const tView = lView[TVIEW];\n  // A registered ViewRef might represent an instance of an\n  // embedded view, in which case we do not need to annotate it.\n  if (tView.type === TViewType.Embedded) {\n    return null;\n  }\n  // Check if it's a root view and if so, retrieve component's\n  // LView from the first slot after the header.\n  if (isRootView(lView)) {\n    lView = lView[HEADER_OFFSET];\n  }\n  return lView;\n}\n\nfunction getTextNodeContent(node: Node): string|undefined {\n  return node.textContent?.replace(/\\s/gm, '');\n}\n\n/**\n * Restores text nodes and separators into the DOM that were lost during SSR\n * serialization. The hydration process replaces empty text nodes and text\n * nodes that are immediately adjacent to other text nodes with comment nodes\n * that this method filters on to restore those missing nodes that the\n * hydration process is expecting to be present.\n *\n * @param node The app's root HTML Element\n */\nexport function processTextNodeMarkersBeforeHydration(node: HTMLElement) {\n  const doc = getDocument();\n  const commentNodesIterator = doc.createNodeIterator(node, NodeFilter.SHOW_COMMENT, {\n    acceptNode(node) {\n      const content = getTextNodeContent(node);\n      const isTextNodeMarker =\n          content === TextNodeMarker.EmptyNode || content === TextNodeMarker.Separator;\n      return isTextNodeMarker ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;\n    }\n  });\n  let currentNode: Comment;\n  // We cannot modify the DOM while using the commentIterator,\n  // because it throws off the iterator state.\n  // So we collect all marker nodes first and then follow up with\n  // applying the changes to the DOM: either inserting an empty node\n  // or just removing the marker if it was used as a separator.\n  const nodes = [];\n  while (currentNode = commentNodesIterator.nextNode() as Comment) {\n    nodes.push(currentNode);\n  }\n  for (const node of nodes) {\n    if (node.textContent === TextNodeMarker.EmptyNode) {\n      node.replaceWith(doc.createTextNode(''));\n    } else {\n      node.remove();\n    }\n  }\n}\n\n/**\n * Internal type that represents a claimed node.\n * Only used in dev mode.\n */\ntype ClaimedNode = {\n  __claimed?: boolean;\n};\n\n/**\n * Marks a node as \"claimed\" by hydration process.\n * This is needed to make assessments in tests whether\n * the hydration process handled all nodes.\n */\nexport function markRNodeAsClaimedByHydration(node: RNode, checkIfAlreadyClaimed = true) {\n  if (!ngDevMode) {\n    throw new Error(\n        'Calling `markRNodeAsClaimedByHydration` in prod mode ' +\n        'is not supported and likely a mistake.');\n  }\n  if (checkIfAlreadyClaimed && isRNodeClaimedForHydration(node)) {\n    throw new Error('Trying to claim a node, which was claimed already.');\n  }\n  (node as ClaimedNode).__claimed = true;\n  ngDevMode.hydratedNodes++;\n}\n\nexport function isRNodeClaimedForHydration(node: RNode): boolean {\n  return !!(node as ClaimedNode).__claimed;\n}\n\nexport function setSegmentHead(\n    hydrationInfo: DehydratedView, index: number, node: RNode|null): void {\n  hydrationInfo.segmentHeads ??= {};\n  hydrationInfo.segmentHeads[index] = node;\n}\n\nexport function getSegmentHead(hydrationInfo: DehydratedView, index: number): RNode|null {\n  return hydrationInfo.segmentHeads?.[index] ?? null;\n}\n\n/**\n * Returns the size of an <ng-container>, using either the information\n * serialized in `ELEMENT_CONTAINERS` (element container size) or by\n * computing the sum of root nodes in all dehydrated views in a given\n * container (in case this `<ng-container>` was also used as a view\n * container host node, e.g. <ng-container *ngIf>).\n */\nexport function getNgContainerSize(hydrationInfo: DehydratedView, index: number): number|null {\n  const data = hydrationInfo.data;\n  let size = data[ELEMENT_CONTAINERS]?.[index] ?? null;\n  // If there is no serialized information available in the `ELEMENT_CONTAINERS` slot,\n  // check if we have info about view containers at this location (e.g.\n  // `<ng-container *ngIf>`) and use container size as a number of root nodes in this\n  // element container.\n  if (size === null && data[CONTAINERS]?.[index]) {\n    size = calcSerializedContainerSize(hydrationInfo, index);\n  }\n  return size;\n}\n\nexport function getSerializedContainerViews(\n    hydrationInfo: DehydratedView, index: number): SerializedContainerView[]|null {\n  return hydrationInfo.data[CONTAINERS]?.[index] ?? null;\n}\n\n/**\n * Computes the size of a serialized container (the number of root nodes)\n * by calculating the sum of root nodes in all dehydrated views in this container.\n */\nexport function calcSerializedContainerSize(hydrationInfo: DehydratedView, index: number): number {\n  const views = getSerializedContainerViews(hydrationInfo, index) ?? [];\n  let numNodes = 0;\n  for (let view of views) {\n    numNodes += view[NUM_ROOT_NODES];\n  }\n  return numNodes;\n}\n"]}

package/esm2020/src/hydration/views.mjs

@@ -0,0 +1,80 @@
+/**
+ * @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 { removeDehydratedViews } from './cleanup';
+import { NUM_ROOT_NODES, TEMPLATE_ID } from './interfaces';
+import { siblingAfter } from './node_lookup_utils';
+/**
+ * Given a current DOM node and a serialized information about the views
+ * in a container, walks over the DOM structure, collecting the list of
+ * dehydrated views.
+ */
+export function locateDehydratedViewsInContainer(currentRNode, serializedViews) {
+    const dehydratedViews = [];
+    for (const serializedView of serializedViews) {
+        const view = {
+            data: serializedView,
+            firstChild: null,
+        };
+        if (serializedView[NUM_ROOT_NODES] > 0) {
+            // Keep reference to the first node in this view,
+            // so it can be accessed while invoking template instructions.
+            view.firstChild = currentRNode;
+            // Move over to the next node after this view, which can
+            // either be a first node of the next view or an anchor comment
+            // node after the last view in a container.
+            currentRNode = siblingAfter(serializedView[NUM_ROOT_NODES], currentRNode);
+        }
+        dehydratedViews.push(view);
+    }
+    return [currentRNode, dehydratedViews];
+}
+/**
+ * Reference to a function that searches for a matching dehydrated views
+ * stored on a given lContainer.
+ * Returns `null` by default, when hydration is not enabled.
+ */
+let _findMatchingDehydratedViewImpl = (lContainer, template) => null;
+/**
+ * Retrieves the next dehydrated view from the LContainer and verifies that
+ * it matches a given template id (from the TView that was used to create this
+ * instance of a view). If the id doesn't match, that means that we are in an
+ * unexpected state and can not complete the reconciliation process. Thus,
+ * all dehydrated views from this LContainer are removed (including corresponding
+ * DOM nodes) and the rendering is performed as if there were no dehydrated views
+ * in this container.
+ */
+function findMatchingDehydratedViewImpl(lContainer, template) {
+    const views = lContainer[DEHYDRATED_VIEWS] ?? [];
+    if (!template || views.length === 0) {
+        return null;
+    }
+    const view = views[0];
+    // Verify whether the first dehydrated view in the container matches
+    // the template id passed to this function (that originated from a TView
+    // that was used to create an instance of an embedded or component views.
+    if (view.data[TEMPLATE_ID] === template) {
+        // If the template id matches - extract the first view and return it.
+        return views.shift();
+    }
+    else {
+        // Otherwise, we are at the state when reconciliation can not be completed,
+        // thus we remove all dehydrated views within this container (remove them
+        // from internal data structures as well as delete associated elements from
+        // the DOM tree).
+        removeDehydratedViews(lContainer);
+        return null;
+    }
+}
+export function enableFindMatchingDehydratedViewImpl() {
+    _findMatchingDehydratedViewImpl = findMatchingDehydratedViewImpl;
+}
+export function findMatchingDehydratedView(lContainer, template) {
+    return _findMatchingDehydratedViewImpl(lContainer, template);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/linker/template_ref.mjs

@@ -48,9 +48,24 @@ const R3TemplateRef = class TemplateRef extends ViewEngineTemplateRef {
         this._declarationTContainer = _declarationTContainer;
         this.elementRef = elementRef;
     }
+    /**
+     * Returns an `ssrId` associated with a TView, which was used to
+     * create this instance of the `TemplateRef`.
+     *
+     * @internal
+     */
+    get ssrId() {
+        return this._declarationTContainer.tView?.ssrId || null;
+    }
     createEmbeddedView(context, injector) {
+        return this.createEmbeddedViewImpl(context, injector, null);
+    }
+    /**
+     * @internal
+     */
+    createEmbeddedViewImpl(context, injector, hydrationInfo) {
         const embeddedTView = this._declarationTContainer.tView;
-        const embeddedLView = createLView(this._declarationLView, embeddedTView, context, 16 /* LViewFlags.CheckAlways */, null, embeddedTView.declTNode, null, null, null, null, injector || null, null);
+        const embeddedLView = createLView(this._declarationLView, embeddedTView, context, 16 /* LViewFlags.CheckAlways */, null, embeddedTView.declTNode, null, null, null, null, injector || null, hydrationInfo || null);
         const declarationLContainer = this._declarationLView[this._declarationTContainer.index];
         ngDevMode && assertLContainer(declarationLContainer);
         embeddedLView[DECLARATION_LCONTAINER] = declarationLContainer;
@@ -84,4 +99,4 @@ export function createTemplateRef(hostTNode, hostLView) {
     }
     return null;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template_ref.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/linker/template_ref.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAC,gBAAgB,EAAC,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAC,WAAW,EAAE,UAAU,EAAC,MAAM,gCAAgC,CAAC;AAEvE,OAAO,EAAC,sBAAsB,EAAqB,OAAO,EAAQ,MAAM,4BAA4B,CAAC;AACrG,OAAO,EAAC,eAAe,EAAE,QAAQ,EAAC,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAC,aAAa,EAAC,MAAM,gBAAgB,CAAC;AAE7C,OAAO,EAAC,gBAAgB,EAAa,MAAM,eAAe,CAAC;AAG3D;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAsB,WAAW;;AAwB/B;;;GAGG;AACI,6BAAiB,GAAiC,iBAAiB,CAAC;SA5BvD,WAAW;AA+BjC,MAAM,qBAAqB,GAAG,WAAW,CAAC;AAE1C,oGAAoG;AACpG,wCAAwC;AACxC,MAAM,aAAa,GAAG,MAAM,WAAe,SAAQ,qBAAwB;IACzE,YACY,iBAAwB,EAAU,sBAAsC,EAChE,UAAsB;QACxC,KAAK,EAAE,CAAC;QAFE,sBAAiB,GAAjB,iBAAiB,CAAO;QAAU,2BAAsB,GAAtB,sBAAsB,CAAgB;QAChE,eAAU,GAAV,UAAU,CAAY;IAE1C,CAAC;IAEQ,kBAAkB,CAAC,OAAU,EAAE,QAAmB;QACzD,MAAM,aAAa,GAAG,IAAI,CAAC,sBAAsB,CAAC,KAAc,CAAC;QACjE,MAAM,aAAa,GAAG,WAAW,CAC7B,IAAI,CAAC,iBAAiB,EAAE,aAAa,EAAE,OAAO,mCAA0B,IAAI,EAC5E,aAAa,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,IAAI,IAAI,EAAE,IAAI,CAAC,CAAC;QAE7E,MAAM,qBAAqB,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC;QACxF,SAAS,IAAI,gBAAgB,CAAC,qBAAqB,CAAC,CAAC;QACrD,aAAa,CAAC,sBAAsB,CAAC,GAAG,qBAAqB,CAAC;QAE9D,MAAM,uBAAuB,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;QAChE,IAAI,uBAAuB,KAAK,IAAI,EAAE;YACpC,aAAa,CAAC,OAAO,CAAC,GAAG,uBAAuB,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC;SACpF;QAED,UAAU,CAAC,aAAa,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;QAElD,OAAO,IAAI,UAAU,CAAI,aAAa,CAAC,CAAC;IAC1C,CAAC;CACF,CAAC;AAEF;;;;GAIG;AACH,MAAM,UAAU,iBAAiB;IAC/B,OAAO,iBAAiB,CAAI,eAAe,EAAG,EAAE,QAAQ,EAAE,CAAC,CAAC;AAC9D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAI,SAAgB,EAAE,SAAgB;IACrE,IAAI,SAAS,CAAC,IAAI,8BAAsB,EAAE;QACxC,SAAS,IAAI,aAAa,CAAC,SAAS,CAAC,KAAK,EAAE,yBAAyB,CAAC,CAAC;QACvE,OAAO,IAAI,aAAa,CACpB,SAAS,EAAE,SAA2B,EAAE,gBAAgB,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC;KACrF;IACD,OAAO,IAAI,CAAC;AACd,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 {Injector} from '../di/injector';\nimport {assertLContainer} from '../render3/assert';\nimport {createLView, renderView} from '../render3/instructions/shared';\nimport {TContainerNode, TNode, TNodeType} from '../render3/interfaces/node';\nimport {DECLARATION_LCONTAINER, LView, LViewFlags, QUERIES, TView} from '../render3/interfaces/view';\nimport {getCurrentTNode, getLView} from '../render3/state';\nimport {ViewRef as R3_ViewRef} from '../render3/view_ref';\nimport {assertDefined} from '../util/assert';\n\nimport {createElementRef, ElementRef} from './element_ref';\nimport {EmbeddedViewRef} from './view_ref';\n\n/**\n * Represents an embedded template that can be used to instantiate embedded views.\n * To instantiate embedded views based on a template, use the `ViewContainerRef`\n * method `createEmbeddedView()`.\n *\n * Access a `TemplateRef` instance by placing a directive on an `<ng-template>`\n * element (or directive prefixed with `*`). The `TemplateRef` for the embedded view\n * is injected into the constructor of the directive,\n * using the `TemplateRef` token.\n *\n * You can also use a `Query` to find a `TemplateRef` associated with\n * a component or a directive.\n *\n * @see `ViewContainerRef`\n * @see [Navigate the Component Tree with DI](guide/dependency-injection-navtree)\n *\n * @publicApi\n */\nexport abstract class TemplateRef<C> {\n  /**\n   * The anchor element in the parent view for this embedded view.\n   *\n   * The data-binding and injection contexts of embedded views created from this `TemplateRef`\n   * inherit from the contexts of this location.\n   *\n   * Typically new embedded views are attached to the view container of this location, but in\n   * advanced use-cases, the view can be attached to a different container while keeping the\n   * data-binding and injection context from the original location.\n   *\n   */\n  // TODO(i): rename to anchor or location\n  abstract readonly elementRef: ElementRef;\n\n  /**\n   * Instantiates an unattached embedded view based on this template.\n   * @param context The data-binding context of the embedded view, as declared\n   * in the `<ng-template>` usage.\n   * @param injector Injector to be used within the embedded view.\n   * @returns The new embedded view object.\n   */\n  abstract createEmbeddedView(context: C, injector?: Injector): EmbeddedViewRef<C>;\n\n  /**\n   * @internal\n   * @nocollapse\n   */\n  static __NG_ELEMENT_ID__: () => TemplateRef<any>| null = injectTemplateRef;\n}\n\nconst ViewEngineTemplateRef = TemplateRef;\n\n// TODO(alxhub): combine interface and implementation. Currently this is challenging since something\n// in g3 depends on them being separate.\nconst R3TemplateRef = class TemplateRef<T> extends ViewEngineTemplateRef<T> {\n  constructor(\n      private _declarationLView: LView, private _declarationTContainer: TContainerNode,\n      public override elementRef: ElementRef) {\n    super();\n  }\n\n  override createEmbeddedView(context: T, injector?: Injector): EmbeddedViewRef<T> {\n    const embeddedTView = this._declarationTContainer.tView as TView;\n    const embeddedLView = createLView(\n        this._declarationLView, embeddedTView, context, LViewFlags.CheckAlways, null,\n        embeddedTView.declTNode, null, null, null, null, injector || null, null);\n\n    const declarationLContainer = this._declarationLView[this._declarationTContainer.index];\n    ngDevMode && assertLContainer(declarationLContainer);\n    embeddedLView[DECLARATION_LCONTAINER] = declarationLContainer;\n\n    const declarationViewLQueries = this._declarationLView[QUERIES];\n    if (declarationViewLQueries !== null) {\n      embeddedLView[QUERIES] = declarationViewLQueries.createEmbeddedView(embeddedTView);\n    }\n\n    renderView(embeddedTView, embeddedLView, context);\n\n    return new R3_ViewRef<T>(embeddedLView);\n  }\n};\n\n/**\n * Creates a TemplateRef given a node.\n *\n * @returns The TemplateRef instance to use\n */\nexport function injectTemplateRef<T>(): TemplateRef<T>|null {\n  return createTemplateRef<T>(getCurrentTNode()!, getLView());\n}\n\n/**\n * Creates a TemplateRef and stores it on the injector.\n *\n * @param hostTNode The node on which a TemplateRef is requested\n * @param hostLView The `LView` to which the node belongs\n * @returns The TemplateRef instance or null if we can't create a TemplateRef on a given node type\n */\nexport function createTemplateRef<T>(hostTNode: TNode, hostLView: LView): TemplateRef<T>|null {\n  if (hostTNode.type & TNodeType.Container) {\n    ngDevMode && assertDefined(hostTNode.tView, 'TView must be allocated');\n    return new R3TemplateRef(\n        hostLView, hostTNode as TContainerNode, createElementRef(hostTNode, hostLView));\n  }\n  return null;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template_ref.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/linker/template_ref.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 {Injector} from '../di/injector';\nimport {DehydratedContainerView} from '../hydration/interfaces';\nimport {assertLContainer} from '../render3/assert';\nimport {createLView, renderView} from '../render3/instructions/shared';\nimport {TContainerNode, TNode, TNodeType} from '../render3/interfaces/node';\nimport {DECLARATION_LCONTAINER, LView, LViewFlags, QUERIES, TView} from '../render3/interfaces/view';\nimport {getCurrentTNode, getLView} from '../render3/state';\nimport {ViewRef as R3_ViewRef} from '../render3/view_ref';\nimport {assertDefined} from '../util/assert';\n\nimport {createElementRef, ElementRef} from './element_ref';\nimport {EmbeddedViewRef} from './view_ref';\n\n/**\n * Represents an embedded template that can be used to instantiate embedded views.\n * To instantiate embedded views based on a template, use the `ViewContainerRef`\n * method `createEmbeddedView()`.\n *\n * Access a `TemplateRef` instance by placing a directive on an `<ng-template>`\n * element (or directive prefixed with `*`). The `TemplateRef` for the embedded view\n * is injected into the constructor of the directive,\n * using the `TemplateRef` token.\n *\n * You can also use a `Query` to find a `TemplateRef` associated with\n * a component or a directive.\n *\n * @see `ViewContainerRef`\n * @see [Navigate the Component Tree with DI](guide/dependency-injection-navtree)\n *\n * @publicApi\n */\nexport abstract class TemplateRef<C> {\n  /**\n   * The anchor element in the parent view for this embedded view.\n   *\n   * The data-binding and injection contexts of embedded views created from this `TemplateRef`\n   * inherit from the contexts of this location.\n   *\n   * Typically new embedded views are attached to the view container of this location, but in\n   * advanced use-cases, the view can be attached to a different container while keeping the\n   * data-binding and injection context from the original location.\n   *\n   */\n  // TODO(i): rename to anchor or location\n  abstract readonly elementRef: ElementRef;\n\n  /**\n   * Instantiates an unattached embedded view based on this template.\n   * @param context The data-binding context of the embedded view, as declared\n   * in the `<ng-template>` usage.\n   * @param injector Injector to be used within the embedded view.\n   * @returns The new embedded view object.\n   */\n  abstract createEmbeddedView(context: C, injector?: Injector): EmbeddedViewRef<C>;\n\n  /**\n   * Implementation of the `createEmbeddedView` function.\n   *\n   * This implementation is internal and allows framework code\n   * to invoke it with extra parameters (e.g. for hydration) without\n   * affecting public API.\n   *\n   * @internal\n   */\n  abstract createEmbeddedViewImpl(\n      context: C, injector?: Injector,\n      hydrationInfo?: DehydratedContainerView|null): EmbeddedViewRef<C>;\n\n  /**\n   * Returns an `ssrId` associated with a TView, which was used to\n   * create this instance of the `TemplateRef`.\n   *\n   * @internal\n   */\n  abstract get ssrId(): string|null;\n\n  /**\n   * @internal\n   * @nocollapse\n   */\n  static __NG_ELEMENT_ID__: () => TemplateRef<any>| null = injectTemplateRef;\n}\n\nconst ViewEngineTemplateRef = TemplateRef;\n\n// TODO(alxhub): combine interface and implementation. Currently this is challenging since something\n// in g3 depends on them being separate.\nconst R3TemplateRef = class TemplateRef<T> extends ViewEngineTemplateRef<T> {\n  constructor(\n      private _declarationLView: LView, private _declarationTContainer: TContainerNode,\n      public override elementRef: ElementRef) {\n    super();\n  }\n\n  /**\n   * Returns an `ssrId` associated with a TView, which was used to\n   * create this instance of the `TemplateRef`.\n   *\n   * @internal\n   */\n  override get ssrId(): string|null {\n    return this._declarationTContainer.tView?.ssrId || null;\n  }\n\n  override createEmbeddedView(context: T, injector?: Injector): EmbeddedViewRef<T> {\n    return this.createEmbeddedViewImpl(context, injector, null);\n  }\n\n  /**\n   * @internal\n   */\n  override createEmbeddedViewImpl(\n      context: T, injector?: Injector,\n      hydrationInfo?: DehydratedContainerView|null): EmbeddedViewRef<T> {\n    const embeddedTView = this._declarationTContainer.tView as TView;\n    const embeddedLView = createLView(\n        this._declarationLView, embeddedTView, context, LViewFlags.CheckAlways, null,\n        embeddedTView.declTNode, null, null, null, null, injector || null, hydrationInfo || null);\n\n    const declarationLContainer = this._declarationLView[this._declarationTContainer.index];\n    ngDevMode && assertLContainer(declarationLContainer);\n    embeddedLView[DECLARATION_LCONTAINER] = declarationLContainer;\n\n    const declarationViewLQueries = this._declarationLView[QUERIES];\n    if (declarationViewLQueries !== null) {\n      embeddedLView[QUERIES] = declarationViewLQueries.createEmbeddedView(embeddedTView);\n    }\n\n    renderView(embeddedTView, embeddedLView, context);\n\n    return new R3_ViewRef<T>(embeddedLView);\n  }\n};\n\n/**\n * Creates a TemplateRef given a node.\n *\n * @returns The TemplateRef instance to use\n */\nexport function injectTemplateRef<T>(): TemplateRef<T>|null {\n  return createTemplateRef<T>(getCurrentTNode()!, getLView());\n}\n\n/**\n * Creates a TemplateRef and stores it on the injector.\n *\n * @param hostTNode The node on which a TemplateRef is requested\n * @param hostLView The `LView` to which the node belongs\n * @returns The TemplateRef instance or null if we can't create a TemplateRef on a given node type\n */\nexport function createTemplateRef<T>(hostTNode: TNode, hostLView: LView): TemplateRef<T>|null {\n  if (hostTNode.type & TNodeType.Container) {\n    ngDevMode && assertDefined(hostTNode.tView, 'TView must be allocated');\n    return new R3TemplateRef(\n        hostLView, hostTNode as TContainerNode, createElementRef(hostTNode, hostLView));\n  }\n  return null;\n}\n"]}