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

package/esm2020/src/hydration/annotate.mjs

@@ -0,0 +1,140 @@
+/**
+ * @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 { isLContainer } 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 { ELEMENT_CONTAINERS } 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;
+    }
+}
+/**
+ * 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 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,
+                };
+                annotateHostElementForHydration(hostElement, lView, context);
+            }
+        }
+    }
+    const allSerializedViews = serializedViewCollection.getAll();
+    if (allSerializedViews.length > 0) {
+        const transferState = appRef.injector.get(TransferState);
+        transferState.set(NGH_DATA_KEY, allSerializedViews);
+    }
+}
+/**
+ * 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])) {
+            // TODO: serialization of LContainers will be added
+            // in followup PRs.
+        }
+        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);
+            }
+        }
+    }
+    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());
+}
+//# 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 {TNode, TNodeType} from '../render3/interfaces/node';\nimport {RElement} from '../render3/interfaces/renderer_dom';\nimport {isLContainer} from '../render3/interfaces/type_checks';\nimport {HEADER_OFFSET, HOST, LView, RENDERER, TView, TVIEW} from '../render3/interfaces/view';\nimport {unwrapRNode} from '../render3/util/view_utils';\nimport {TransferState} from '../transfer_state';\n\nimport {ELEMENT_CONTAINERS, SerializedView} from './interfaces';\nimport {SKIP_HYDRATION_ATTR_NAME} from './skip_hydration';\nimport {getComponentLViewForHydration, NGH_ATTR_NAME, NGH_DATA_KEY} 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 * 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}\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 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        };\n        annotateHostElementForHydration(hostElement as HTMLElement, lView, context);\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 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      // TODO: serialization of LContainers will be added\n      // in followup PRs.\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      }\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"]}

package/esm2020/src/hydration/api.mjs

@@ -0,0 +1,120 @@
+/**
+ * @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 { enableLocateOrCreateElementNodeImpl } from '../render3/instructions/element';
+import { enableLocateOrCreateElementContainerNodeImpl } from '../render3/instructions/element_container';
+import { enableLocateOrCreateTextNodeImpl } from '../render3/instructions/text';
+import { IS_HYDRATION_FEATURE_ENABLED, PRESERVE_HOST_CONTENT } from './tokens';
+import { enableRetrieveHydrationInfoImpl } from './utils';
+/**
+ * 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();
+    }
+}
+/**
+ * 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,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

package/esm2020/src/hydration/error_handling.mjs

@@ -0,0 +1,29 @@
+/**
+ * @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) {
+    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) {
+    if (!node.nextSibling) {
+        // TODO: improve error message and use RuntimeError instead.
+        throw new Error(`Unexpected state: insufficient number of sibling nodes.`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/hydration/interfaces.mjs

@@ -0,0 +1,10 @@
+/**
+ * @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
+ */
+/* Represents a key in NghDom that holds information about <ng-container>s. */
+export const ELEMENT_CONTAINERS = 'e';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/hydration/node_lookup_utils.mjs

@@ -0,0 +1,75 @@
+/**
+ * @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 { HEADER_OFFSET } from '../render3/interfaces/view';
+import { getNativeByTNode } from '../render3/util/view_utils';
+import { assertDefined } from '../util/assert';
+import { validateSiblingNodeExists } from './error_handling';
+/** Whether current TNode is a first node in an <ng-container>. */
+function isFirstElementInNgContainer(tNode) {
+    return !tNode.prev && tNode.parent?.type === 8 /* TNodeType.ElementContainer */;
+}
+/** Returns first element from a DOM segment that corresponds to this <ng-container>. */
+function getDehydratedNgContainer(hydrationInfo, tContainerNode) {
+    const noOffsetIndex = tContainerNode.index - HEADER_OFFSET;
+    const ngContainer = hydrationInfo.ngContainers?.[noOffsetIndex];
+    ngDevMode &&
+        assertDefined(ngContainer, 'Unexpected state: no hydration info available for a given TNode, ' +
+            'which represents an element container.');
+    return ngContainer;
+}
+/**
+ * Locate a node in DOM tree that corresponds to a given TNode.
+ *
+ * @param hydrationInfo The hydration annotation data
+ * @param tView the current tView
+ * @param lView the current lView
+ * @param tNode the current tNode
+ * @returns an RNode that represents a given tNode
+ */
+export function locateNextRNode(hydrationInfo, tView, lView, tNode) {
+    let native = null;
+    if (tView.firstChild === tNode) {
+        // We create a first node in this view, so we use a reference
+        // to the first child in this DOM segment.
+        native = hydrationInfo.firstChild;
+    }
+    else {
+        // Locate a node based on a previous sibling or a parent node.
+        const previousTNodeParent = tNode.prev === null;
+        const previousTNode = (tNode.prev ?? tNode.parent);
+        ngDevMode &&
+            assertDefined(previousTNode, 'Unexpected state: current TNode does not have a connection ' +
+                'to the previous node or a parent node.');
+        const previousRElement = getNativeByTNode(previousTNode, lView);
+        if (isFirstElementInNgContainer(tNode)) {
+            const ngContainer = getDehydratedNgContainer(hydrationInfo, tNode.parent);
+            native = ngContainer.firstChild ?? null;
+        }
+        else {
+            if (previousTNodeParent) {
+                native = previousRElement.firstChild;
+            }
+            else {
+                native = previousRElement.nextSibling;
+            }
+        }
+    }
+    return native;
+}
+/**
+ * Skips over a specified number of nodes and returns the next sibling node after that.
+ */
+export function siblingAfter(skip, from) {
+    let currentNode = from;
+    for (let i = 0; i < skip; i++) {
+        ngDevMode && validateSiblingNodeExists(currentNode);
+        currentNode = currentNode.nextSibling;
+    }
+    return currentNode;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/hydration/skip_hydration.mjs

@@ -0,0 +1,34 @@
+/**
+ * @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
+ */
+/**
+ * The name of an attribute that can be added to the hydration boundary node
+ * (component host node) to disable hydration for the content within that boundary.
+ */
+export const SKIP_HYDRATION_ATTR_NAME = 'ngSkipHydration';
+/**
+ * Helper function to check if a given node has the 'ngSkipHydration' attribute
+ */
+export function hasNgSkipHydrationAttr(tNode) {
+    const SKIP_HYDRATION_ATTR_NAME_LOWER_CASE = SKIP_HYDRATION_ATTR_NAME.toLowerCase();
+    const attrs = tNode.mergedAttrs;
+    if (attrs === null)
+        return false;
+    // only ever look at the attribute name and skip the values
+    for (let i = 0; i < attrs.length; i += 2) {
+        const value = attrs[i];
+        // This is a marker, which means that the static attributes section is over,
+        // so we can exit early.
+        if (typeof value === 'number')
+            return false;
+        if (typeof value === 'string' && value.toLowerCase() === SKIP_HYDRATION_ATTR_NAME_LOWER_CASE) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/hydration/tokens.mjs

@@ -0,0 +1,25 @@
+/**
+ * @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 { InjectionToken } from '../di/injection_token';
+const NG_DEV_MODE = typeof ngDevMode === 'undefined' || !!ngDevMode;
+/**
+ * Internal token that specifies whether hydration is enabled.
+ */
+export const IS_HYDRATION_FEATURE_ENABLED = new InjectionToken(NG_DEV_MODE ? 'IS_HYDRATION_FEATURE_ENABLED' : '');
+// By default (in client rendering mode), we remove all the contents
+// of the host element and render an application after that.
+export const PRESERVE_HOST_CONTENT_DEFAULT = false;
+/**
+ * Internal token that indicates whether host element content should be
+ * retained during the bootstrap.
+ */
+export const PRESERVE_HOST_CONTENT = new InjectionToken(NG_DEV_MODE ? 'PRESERVE_HOST_CONTENT' : '', {
+    providedIn: 'root',
+    factory: () => PRESERVE_HOST_CONTENT_DEFAULT,
+});
+//# sourceMappingURL=data:application/json;base64,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