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

package/esm2020/src/hydration/views.mjs

@@ -0,0 +1,84 @@
+/**
+ * @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 { MULTIPLIER, 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) {
+        // Repeats a view multiple times as needed, based on the serialized information
+        // (for example, for *ngFor-produced views).
+        for (let i = 0; i < (serializedView[MULTIPLIER] ?? 1); i++) {
+            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/destroy_ref.mjs

@@ -6,12 +6,14 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { getLView } from '../render3/state';
-import { storeLViewOnDestroy } from '../render3/util/view_utils';
+import { removeLViewOnDestroy, storeLViewOnDestroy } from '../render3/util/view_utils';
 /**
  * `DestroyRef` lets you set callbacks to run for any cleanup or destruction behavior.
  * The scope of this destruction depends on where `DestroyRef` is injected. If `DestroyRef`
  * is injected in a component or directive, the callbacks run when that component or
  * directive is destroyed. Otherwise the callbacks run when a corresponding injector is destroyed.
+ *
+ * @publicApi
  */
 class DestroyRef {
 }
@@ -33,9 +35,10 @@ class NodeInjectorDestroyRef extends DestroyRef {
     }
     onDestroy(callback) {
         storeLViewOnDestroy(this._lView, callback);
+        return () => removeLViewOnDestroy(this._lView, callback);
     }
 }
 function injectDestroyRef() {
     return new NodeInjectorDestroyRef(getLView());
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# 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":"AAAA;;;;;;GAMG;AAIH,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;;AA6C/B;;;GAGG;AACI,6BAAiB,GAAiC,iBAAiB,CAAC;SAjDvD,WAAW;AAoDjC,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;IAED;;;;;OAKG;IACH,IAAa,KAAK;QAChB,OAAO,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,KAAK,IAAI,IAAI,CAAC;IAC1D,CAAC;IAEQ,kBAAkB,CAAC,OAAU,EAAE,QAAmB;QACzD,OAAO,IAAI,CAAC,sBAAsB,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;IAC9D,CAAC;IAED;;OAEG;IACM,sBAAsB,CAC3B,OAAU,EAAE,QAAmB,EAC/B,aAA4C;QAC9C,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,aAAa,IAAI,IAAI,CAAC,CAAC;QAE9F,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 {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"]}