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

package/esm2020/src/hydration/error_handling.mjs

@@ -5,33 +5,375 @@
  * 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 { RuntimeError } from '../errors';
+import { getDeclarationComponentDef } from '../render3/instructions/element_validation';
+import { TVIEW } from '../render3/interfaces/view';
+import { getParentRElement } from '../render3/node_manipulation';
+const AT_THIS_LOCATION = '<-- AT THIS LOCATION';
 /**
- * Verifies whether a given node matches an expected criteria,
- * based on internal data structure state.
+ * Retrieves a user friendly string for a given TNodeType for use in
+ * friendly error messages
+ *
+ * @param tNodeType
+ * @returns
  */
-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.`);
+function getFriendlyStringFromTNodeType(tNodeType) {
+    switch (tNodeType) {
+        case 4 /* TNodeType.Container */:
+            return 'view container';
+        case 2 /* TNodeType.Element */:
+            return 'element';
+        case 8 /* TNodeType.ElementContainer */:
+            return 'ng-container';
+        case 32 /* TNodeType.Icu */:
+            return 'icu';
+        case 64 /* TNodeType.Placeholder */:
+            return 'i18n';
+        case 16 /* TNodeType.Projection */:
+            return 'projection';
+        case 1 /* TNodeType.Text */:
+            return 'text';
+        default:
+            // This should not happen as we cover all possible TNode types above.
+            return '<unknown>';
+    }
+}
+/**
+ * Validates that provided nodes match during the hydration process.
+ */
+export function validateMatchingNode(node, nodeType, tagName, lView, tNode, isViewContainerAnchor = false) {
+    if (!node ||
+        (node.nodeType !== nodeType ||
+            (node.nodeType === Node.ELEMENT_NODE &&
+                node.tagName.toLowerCase() !== tagName?.toLowerCase()))) {
+        const expectedNode = shortRNodeDescription(nodeType, tagName, null);
+        let header = `During hydration Angular expected ${expectedNode} but `;
+        const hostComponentDef = getDeclarationComponentDef(lView);
+        const componentClassName = hostComponentDef?.type?.name;
+        const expected = `Angular expected this DOM:\n\n${describeExpectedDom(lView, tNode, isViewContainerAnchor)}\n\n`;
+        let actual = '';
+        if (!node) {
+            // No node found during hydration.
+            header += `the node was not found.\n\n`;
+        }
+        else {
+            const actualNode = shortRNodeDescription(node.nodeType, node.tagName ?? null, node.textContent ?? null);
+            header += `found ${actualNode}.\n\n`;
+            actual = `Actual DOM is:\n\n${describeDomFromNode(node)}\n\n`;
+        }
+        const footer = getHydrationErrorFooter(componentClassName);
+        const message = header + expected + actual + getHydrationAttributeNote() + footer;
+        throw new RuntimeError(500 /* RuntimeErrorCode.HYDRATION_NODE_MISMATCH */, message);
     }
 }
 /**
- * Verifies whether next sibling node exists.
+ * Validates that a given node has sibling nodes
  */
 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.`);
+        const header = 'During hydration Angular expected more sibling nodes to be present.\n\n';
+        const actual = `Actual DOM is:\n\n${describeDomFromNode(node)}\n\n`;
+        const footer = getHydrationErrorFooter();
+        const message = header + actual + footer;
+        throw new RuntimeError(501 /* RuntimeErrorCode.HYDRATION_MISSING_SIBLINGS */, message);
     }
 }
+/**
+ * Validates that a node exists or throws
+ */
 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.`);
+        throw new RuntimeError(502 /* RuntimeErrorCode.HYDRATION_MISSING_NODE */, `Hydration expected an element to be present at this location.`);
+    }
+}
+/**
+ * Builds the hydration error message when a node is not found
+ *
+ * @param lView the LView where the node exists
+ * @param tNode the TNode
+ */
+export function nodeNotFoundError(lView, tNode) {
+    const header = 'During serialization, Angular was unable to find an element in the DOM:\n\n';
+    const expected = `${describeExpectedDom(lView, tNode, false)}\n\n`;
+    const footer = getHydrationErrorFooter();
+    throw new RuntimeError(502 /* RuntimeErrorCode.HYDRATION_MISSING_NODE */, header + expected + footer);
+}
+/**
+ * Builds a hydration error message when a node is not found at a path location
+ *
+ * @param host the Host Node
+ * @param path the path to the node
+ */
+export function nodeNotFoundAtPathError(host, path) {
+    const header = `During hydration Angular was unable to locate a node ` +
+        `using the "${path}" path, starting from the ${describeRNode(host)} node.\n\n`;
+    const footer = getHydrationErrorFooter();
+    throw new RuntimeError(502 /* RuntimeErrorCode.HYDRATION_MISSING_NODE */, header + footer);
+}
+/**
+ * Builds the hydration error message in the case that dom nodes are created outside of
+ * the Angular context and are being used as projected nodes
+ *
+ * @param lView the LView
+ * @param tNode the TNode
+ * @returns an error
+ */
+export function unsupportedProjectionOfDomNodes(rNode) {
+    const header = 'During serialization, Angular detected DOM nodes ' +
+        'that were created outside of Angular context and provided as projectable nodes ' +
+        '(likely via `ViewContainerRef.createComponent` or `createComponent` APIs). ' +
+        'Hydration is not supported for such cases, consider refactoring the code to avoid ' +
+        'this pattern or using `ngSkipHydration` on the host element of the component.\n\n';
+    const actual = `${describeDomFromNode(rNode)}\n\n`;
+    const message = header + actual + getHydrationAttributeNote();
+    return new RuntimeError(503 /* RuntimeErrorCode.UNSUPPORTED_PROJECTION_DOM_NODES */, message);
+}
+/**
+ * Builds the hydration error message in the case that ngSkipHydration was used on a
+ * node that is not a component host element or host binding
+ *
+ * @param rNode the HTML Element
+ * @returns an error
+ */
+export function invalidSkipHydrationHost(rNode) {
+    const header = 'The `ngSkipHydration` flag is applied on a node ' +
+        'that doesn\'t act as a component host. Hydration can be ' +
+        'skipped only on per-component basis.\n\n';
+    const actual = `${describeDomFromNode(rNode)}\n\n`;
+    const footer = 'Please move the `ngSkipHydration` attribute to the component host element.';
+    const message = header + actual + footer;
+    return new RuntimeError(504 /* RuntimeErrorCode.INVALID_SKIP_HYDRATION_HOST */, message);
+}
+/**
+ * Builds the hydration error message in the case that a user is attempting to enable
+ * hydration on internationalized nodes, which is not yet supported.
+ *
+ * @param rNode the HTML Element
+ * @returns an error
+ */
+export function notYetSupportedI18nBlockError(rNode) {
+    const header = 'Hydration for nodes marked with `i18n` is not yet supported. ' +
+        'You can opt-out a component that uses `i18n` in a template using ' +
+        'the `ngSkipHydration` attribute or fall back to the previous ' +
+        'hydration logic (which re-creates the application structure).\n\n';
+    const actual = `${describeDomFromNode(rNode)}\n\n`;
+    const message = header + actual;
+    return new RuntimeError(518 /* RuntimeErrorCode.HYDRATION_I18N_NOT_YET_SUPPORTED */, message);
+}
+// Stringification methods
+/**
+ * Stringifies a given TNode's attributes
+ *
+ * @param tNode a provided TNode
+ * @returns string
+ */
+function stringifyTNodeAttrs(tNode) {
+    const results = [];
+    if (tNode.attrs) {
+        for (let i = 0; i < tNode.attrs.length;) {
+            const attrName = tNode.attrs[i++];
+            // Once we reach the first flag, we know that the list of
+            // attributes is over.
+            if (typeof attrName == 'number') {
+                break;
+            }
+            const attrValue = tNode.attrs[i++];
+            results.push(`${attrName}="${shorten(attrValue)}"`);
+        }
+    }
+    return results.join(' ');
+}
+/**
+ * The list of internal attributes that should be filtered out while
+ * producing an error message.
+ */
+const internalAttrs = new Set(['ngh', 'ng-version', 'ng-server-context']);
+/**
+ * Stringifies an HTML Element's attributes
+ *
+ * @param rNode an HTML Element
+ * @returns string
+ */
+function stringifyRNodeAttrs(rNode) {
+    const results = [];
+    for (let i = 0; i < rNode.attributes.length; i++) {
+        const attr = rNode.attributes[i];
+        if (internalAttrs.has(attr.name))
+            continue;
+        results.push(`${attr.name}="${shorten(attr.value)}"`);
+    }
+    return results.join(' ');
+}
+// Methods for Describing the DOM
+/**
+ * Converts a tNode to a helpful readable string value for use in error messages
+ *
+ * @param tNode a given TNode
+ * @param innerContent the content of the node
+ * @returns string
+ */
+function describeTNode(tNode, innerContent = '…') {
+    switch (tNode.type) {
+        case 1 /* TNodeType.Text */:
+            const content = tNode.value ? `(${tNode.value})` : '';
+            return `#text${content}`;
+        case 2 /* TNodeType.Element */:
+            const attrs = stringifyTNodeAttrs(tNode);
+            const tag = tNode.value.toLowerCase();
+            return `<${tag}${attrs ? ' ' + attrs : ''}>${innerContent}</${tag}>`;
+        case 8 /* TNodeType.ElementContainer */:
+            return '<!-- ng-container -->';
+        case 4 /* TNodeType.Container */:
+            return '<!-- container -->';
+        default:
+            const typeAsString = getFriendlyStringFromTNodeType(tNode.type);
+            return `#node(${typeAsString})`;
+    }
+}
+/**
+ * Converts an RNode to a helpful readable string value for use in error messages
+ *
+ * @param rNode a given RNode
+ * @param innerContent the content of the node
+ * @returns string
+ */
+function describeRNode(rNode, innerContent = '…') {
+    const node = rNode;
+    switch (node.nodeType) {
+        case Node.ELEMENT_NODE:
+            const tag = node.tagName.toLowerCase();
+            const attrs = stringifyRNodeAttrs(node);
+            return `<${tag}${attrs ? ' ' + attrs : ''}>${innerContent}</${tag}>`;
+        case Node.TEXT_NODE:
+            const content = node.textContent ? shorten(node.textContent) : '';
+            return `#text${content ? `(${content})` : ''}`;
+        case Node.COMMENT_NODE:
+            return `<!-- ${shorten(node.textContent ?? '')} -->`;
+        default:
+            return `#node(${node.nodeType})`;
+    }
+}
+/**
+ * Builds the string containing the expected DOM present given the LView and TNode
+ * values for a readable error message
+ *
+ * @param lView the lView containing the DOM
+ * @param tNode the tNode
+ * @param isViewContainerAnchor boolean
+ * @returns string
+ */
+function describeExpectedDom(lView, tNode, isViewContainerAnchor) {
+    const spacer = '  ';
+    let content = '';
+    if (tNode.prev) {
+        content += spacer + '…\n';
+        content += spacer + describeTNode(tNode.prev) + '\n';
+    }
+    else if (tNode.type && tNode.type & 12 /* TNodeType.AnyContainer */) {
+        content += spacer + '…\n';
+    }
+    if (isViewContainerAnchor) {
+        content += spacer + describeTNode(tNode) + '\n';
+        content += spacer + `<!-- container -->  ${AT_THIS_LOCATION}\n`;
+    }
+    else {
+        content += spacer + describeTNode(tNode) + `  ${AT_THIS_LOCATION}\n`;
+    }
+    content += spacer + '…\n';
+    const parentRNode = tNode.type ? getParentRElement(lView[TVIEW], tNode, lView) : null;
+    if (parentRNode) {
+        content = describeRNode(parentRNode, '\n' + content);
+    }
+    return content;
+}
+/**
+ * Builds the string containing the DOM present around a given RNode for a
+ * readable error message
+ *
+ * @param node the RNode
+ * @returns string
+ */
+function describeDomFromNode(node) {
+    const spacer = '  ';
+    let content = '';
+    const currentNode = node;
+    if (currentNode.previousSibling) {
+        content += spacer + '…\n';
+        content += spacer + describeRNode(currentNode.previousSibling) + '\n';
+    }
+    content += spacer + describeRNode(currentNode) + `  ${AT_THIS_LOCATION}\n`;
+    if (node.nextSibling) {
+        content += spacer + '…\n';
+    }
+    if (node.parentNode) {
+        content = describeRNode(currentNode.parentNode, '\n' + content);
+    }
+    return content;
+}
+/**
+ * Shortens the description of a given RNode by its type for readability
+ *
+ * @param nodeType the type of node
+ * @param tagName the node tag name
+ * @param textContent the text content in the node
+ * @returns string
+ */
+function shortRNodeDescription(nodeType, tagName, textContent) {
+    switch (nodeType) {
+        case Node.ELEMENT_NODE:
+            return `<${tagName.toLowerCase()}>`;
+        case Node.TEXT_NODE:
+            const content = textContent ? ` (with the "${shorten(textContent)}" content)` : '';
+            return `a text node${content}`;
+        case Node.COMMENT_NODE:
+            return 'a comment node';
+        default:
+            return `#node(nodeType=${nodeType})`;
+    }
+}
+/**
+ * Builds the footer hydration error message
+ *
+ * @param componentClassName the name of the component class
+ * @returns string
+ */
+function getHydrationErrorFooter(componentClassName) {
+    const componentInfo = componentClassName ? `the "${componentClassName}"` : 'corresponding';
+    return `To fix this problem:\n` +
+        `  * check ${componentInfo} component for hydration-related issues\n` +
+        `  * or skip hydration by adding the \`ngSkipHydration\` attribute ` +
+        `to its host node in a template`;
+}
+/**
+ * An attribute related note for hydration errors
+ */
+function getHydrationAttributeNote() {
+    return 'Note: attributes are only displayed to better represent the DOM' +
+        ' but have no effect on hydration mismatches.\n\n';
+}
+// Node string utility functions
+/**
+ * Strips all newlines out of a given string
+ *
+ * @param input a string to be cleared of new line characters
+ * @returns
+ */
+function stripNewlines(input) {
+    return input.replace(/\s+/gm, '');
+}
+/**
+ * Reduces a string down to a maximum length of characters with ellipsis for readability
+ *
+ * @param input a string input
+ * @param maxLength a maximum length in characters
+ * @returns string
+ */
+function shorten(input, maxLength = 50) {
+    if (!input) {
+        return '';
     }
+    input = stripNewlines(input);
+    return input.length > maxLength ? `${input.substring(0, maxLength - 1)}…` : input;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error_handling.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/hydration/error_handling.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 {RuntimeError, RuntimeErrorCode} from '../errors';\nimport {getDeclarationComponentDef} from '../render3/instructions/element_validation';\nimport {TNode, TNodeType} from '../render3/interfaces/node';\nimport {RNode} from '../render3/interfaces/renderer_dom';\nimport {LView, TVIEW} from '../render3/interfaces/view';\nimport {getParentRElement} from '../render3/node_manipulation';\n\nconst AT_THIS_LOCATION = '<-- AT THIS LOCATION';\n\n/**\n * Retrieves a user friendly string for a given TNodeType for use in\n * friendly error messages\n *\n * @param tNodeType\n * @returns\n */\nfunction getFriendlyStringFromTNodeType(tNodeType: TNodeType): string {\n  switch (tNodeType) {\n    case TNodeType.Container:\n      return 'view container';\n    case TNodeType.Element:\n      return 'element';\n    case TNodeType.ElementContainer:\n      return 'ng-container';\n    case TNodeType.Icu:\n      return 'icu';\n    case TNodeType.Placeholder:\n      return 'i18n';\n    case TNodeType.Projection:\n      return 'projection';\n    case TNodeType.Text:\n      return 'text';\n    default:\n      // This should not happen as we cover all possible TNode types above.\n      return '<unknown>';\n  }\n}\n\n/**\n * Validates that provided nodes match during the hydration process.\n */\nexport function validateMatchingNode(\n    node: RNode, nodeType: number, tagName: string|null, lView: LView, tNode: TNode,\n    isViewContainerAnchor = false): void {\n  if (!node ||\n      ((node as Node).nodeType !== nodeType ||\n       ((node as Node).nodeType === Node.ELEMENT_NODE &&\n        (node as HTMLElement).tagName.toLowerCase() !== tagName?.toLowerCase()))) {\n    const expectedNode = shortRNodeDescription(nodeType, tagName, null);\n    let header = `During hydration Angular expected ${expectedNode} but `;\n\n    const hostComponentDef = getDeclarationComponentDef(lView);\n    const componentClassName = hostComponentDef?.type?.name;\n\n    const expected = `Angular expected this DOM:\\n\\n${\n        describeExpectedDom(lView, tNode, isViewContainerAnchor)}\\n\\n`;\n\n    let actual = '';\n\n    if (!node) {\n      // No node found during hydration.\n      header += `the node was not found.\\n\\n`;\n    } else {\n      const actualNode = shortRNodeDescription(\n          (node as Node).nodeType, (node as HTMLElement).tagName ?? null,\n          (node as HTMLElement).textContent ?? null);\n\n      header += `found ${actualNode}.\\n\\n`;\n      actual = `Actual DOM is:\\n\\n${describeDomFromNode(node)}\\n\\n`;\n    }\n\n    const footer = getHydrationErrorFooter(componentClassName);\n    const message = header + expected + actual + getHydrationAttributeNote() + footer;\n    throw new RuntimeError(RuntimeErrorCode.HYDRATION_NODE_MISMATCH, message);\n  }\n}\n\n/**\n * Validates that a given node has sibling nodes\n */\nexport function validateSiblingNodeExists(node: RNode|null): void {\n  validateNodeExists(node);\n  if (!node!.nextSibling) {\n    const header = 'During hydration Angular expected more sibling nodes to be present.\\n\\n';\n    const actual = `Actual DOM is:\\n\\n${describeDomFromNode(node!)}\\n\\n`;\n    const footer = getHydrationErrorFooter();\n\n    const message = header + actual + footer;\n    throw new RuntimeError(RuntimeErrorCode.HYDRATION_MISSING_SIBLINGS, message);\n  }\n}\n\n/**\n * Validates that a node exists or throws\n */\nexport function validateNodeExists(node: RNode|null): void {\n  if (!node) {\n    throw new RuntimeError(\n        RuntimeErrorCode.HYDRATION_MISSING_NODE,\n        `Hydration expected an element to be present at this location.`);\n  }\n}\n\n/**\n * Builds the hydration error message when a node is not found\n *\n * @param lView the LView where the node exists\n * @param tNode the TNode\n */\nexport function nodeNotFoundError(lView: LView, tNode: TNode): Error {\n  const header = 'During serialization, Angular was unable to find an element in the DOM:\\n\\n';\n  const expected = `${describeExpectedDom(lView, tNode, false)}\\n\\n`;\n  const footer = getHydrationErrorFooter();\n\n  throw new RuntimeError(RuntimeErrorCode.HYDRATION_MISSING_NODE, header + expected + footer);\n}\n\n/**\n * Builds a hydration error message when a node is not found at a path location\n *\n * @param host the Host Node\n * @param path the path to the node\n */\nexport function nodeNotFoundAtPathError(host: Node, path: string): Error {\n  const header = `During hydration Angular was unable to locate a node ` +\n      `using the \"${path}\" path, starting from the ${describeRNode(host)} node.\\n\\n`;\n  const footer = getHydrationErrorFooter();\n\n  throw new RuntimeError(RuntimeErrorCode.HYDRATION_MISSING_NODE, header + footer);\n}\n\n\n/**\n * Builds the hydration error message in the case that dom nodes are created outside of\n * the Angular context and are being used as projected nodes\n *\n * @param lView the LView\n * @param tNode the TNode\n * @returns an error\n */\nexport function unsupportedProjectionOfDomNodes(rNode: RNode): Error {\n  const header = 'During serialization, Angular detected DOM nodes ' +\n      'that were created outside of Angular context and provided as projectable nodes ' +\n      '(likely via `ViewContainerRef.createComponent` or `createComponent` APIs). ' +\n      'Hydration is not supported for such cases, consider refactoring the code to avoid ' +\n      'this pattern or using `ngSkipHydration` on the host element of the component.\\n\\n';\n  const actual = `${describeDomFromNode(rNode)}\\n\\n`;\n  const message = header + actual + getHydrationAttributeNote();\n  return new RuntimeError(RuntimeErrorCode.UNSUPPORTED_PROJECTION_DOM_NODES, message);\n}\n\n/**\n * Builds the hydration error message in the case that ngSkipHydration was used on a\n * node that is not a component host element or host binding\n *\n * @param rNode the HTML Element\n * @returns an error\n */\nexport function invalidSkipHydrationHost(rNode: RNode): Error {\n  const header = 'The `ngSkipHydration` flag is applied on a node ' +\n      'that doesn\\'t act as a component host. Hydration can be ' +\n      'skipped only on per-component basis.\\n\\n';\n  const actual = `${describeDomFromNode(rNode)}\\n\\n`;\n  const footer = 'Please move the `ngSkipHydration` attribute to the component host element.';\n  const message = header + actual + footer;\n  return new RuntimeError(RuntimeErrorCode.INVALID_SKIP_HYDRATION_HOST, message);\n}\n\n/**\n * Builds the hydration error message in the case that a user is attempting to enable\n * hydration on internationalized nodes, which is not yet supported.\n *\n * @param rNode the HTML Element\n * @returns an error\n */\nexport function notYetSupportedI18nBlockError(rNode: RNode): Error {\n  const header = 'Hydration for nodes marked with `i18n` is not yet supported. ' +\n      'You can opt-out a component that uses `i18n` in a template using ' +\n      'the `ngSkipHydration` attribute or fall back to the previous ' +\n      'hydration logic (which re-creates the application structure).\\n\\n';\n  const actual = `${describeDomFromNode(rNode)}\\n\\n`;\n  const message = header + actual;\n  return new RuntimeError(RuntimeErrorCode.HYDRATION_I18N_NOT_YET_SUPPORTED, message);\n}\n\n// Stringification methods\n\n/**\n * Stringifies a given TNode's attributes\n *\n * @param tNode a provided TNode\n * @returns string\n */\nfunction stringifyTNodeAttrs(tNode: TNode): string {\n  const results = [];\n  if (tNode.attrs) {\n    for (let i = 0; i < tNode.attrs.length;) {\n      const attrName = tNode.attrs[i++];\n      // Once we reach the first flag, we know that the list of\n      // attributes is over.\n      if (typeof attrName == 'number') {\n        break;\n      }\n      const attrValue = tNode.attrs[i++];\n      results.push(`${attrName}=\"${shorten(attrValue as string)}\"`);\n    }\n  }\n  return results.join(' ');\n}\n\n/**\n * The list of internal attributes that should be filtered out while\n * producing an error message.\n */\nconst internalAttrs = new Set(['ngh', 'ng-version', 'ng-server-context']);\n\n/**\n * Stringifies an HTML Element's attributes\n *\n * @param rNode an HTML Element\n * @returns string\n */\nfunction stringifyRNodeAttrs(rNode: HTMLElement): string {\n  const results = [];\n  for (let i = 0; i < rNode.attributes.length; i++) {\n    const attr = rNode.attributes[i];\n    if (internalAttrs.has(attr.name)) continue;\n    results.push(`${attr.name}=\"${shorten(attr.value)}\"`);\n  }\n  return results.join(' ');\n}\n\n// Methods for Describing the DOM\n\n/**\n * Converts a tNode to a helpful readable string value for use in error messages\n *\n * @param tNode a given TNode\n * @param innerContent the content of the node\n * @returns string\n */\nfunction describeTNode(tNode: TNode, innerContent: string = '…'): string {\n  switch (tNode.type) {\n    case TNodeType.Text:\n      const content = tNode.value ? `(${tNode.value})` : '';\n      return `#text${content}`;\n    case TNodeType.Element:\n      const attrs = stringifyTNodeAttrs(tNode);\n      const tag = tNode.value.toLowerCase();\n      return `<${tag}${attrs ? ' ' + attrs : ''}>${innerContent}</${tag}>`;\n    case TNodeType.ElementContainer:\n      return '<!-- ng-container -->';\n    case TNodeType.Container:\n      return '<!-- container -->';\n    default:\n      const typeAsString = getFriendlyStringFromTNodeType(tNode.type);\n      return `#node(${typeAsString})`;\n  }\n}\n\n/**\n * Converts an RNode to a helpful readable string value for use in error messages\n *\n * @param rNode a given RNode\n * @param innerContent the content of the node\n * @returns string\n */\nfunction describeRNode(rNode: RNode, innerContent: string = '…'): string {\n  const node = rNode as HTMLElement;\n  switch (node.nodeType) {\n    case Node.ELEMENT_NODE:\n      const tag = node.tagName!.toLowerCase();\n      const attrs = stringifyRNodeAttrs(node);\n      return `<${tag}${attrs ? ' ' + attrs : ''}>${innerContent}</${tag}>`;\n    case Node.TEXT_NODE:\n      const content = node.textContent ? shorten(node.textContent) : '';\n      return `#text${content ? `(${content})` : ''}`;\n    case Node.COMMENT_NODE:\n      return `<!-- ${shorten(node.textContent ?? '')} -->`;\n    default:\n      return `#node(${node.nodeType})`;\n  }\n}\n\n/**\n * Builds the string containing the expected DOM present given the LView and TNode\n * values for a readable error message\n *\n * @param lView the lView containing the DOM\n * @param tNode the tNode\n * @param isViewContainerAnchor boolean\n * @returns string\n */\nfunction describeExpectedDom(lView: LView, tNode: TNode, isViewContainerAnchor: boolean): string {\n  const spacer = '  ';\n  let content = '';\n  if (tNode.prev) {\n    content += spacer + '…\\n';\n    content += spacer + describeTNode(tNode.prev) + '\\n';\n  } else if (tNode.type && tNode.type & TNodeType.AnyContainer) {\n    content += spacer + '…\\n';\n  }\n  if (isViewContainerAnchor) {\n    content += spacer + describeTNode(tNode) + '\\n';\n    content += spacer + `<!-- container -->  ${AT_THIS_LOCATION}\\n`;\n  } else {\n    content += spacer + describeTNode(tNode) + `  ${AT_THIS_LOCATION}\\n`;\n  }\n  content += spacer + '…\\n';\n\n  const parentRNode = tNode.type ? getParentRElement(lView[TVIEW], tNode, lView) : null;\n  if (parentRNode) {\n    content = describeRNode(parentRNode as unknown as Node, '\\n' + content);\n  }\n  return content;\n}\n\n/**\n * Builds the string containing the DOM present around a given RNode for a\n * readable error message\n *\n * @param node the RNode\n * @returns string\n */\nfunction describeDomFromNode(node: RNode): string {\n  const spacer = '  ';\n  let content = '';\n  const currentNode = node as HTMLElement;\n  if (currentNode.previousSibling) {\n    content += spacer + '…\\n';\n    content += spacer + describeRNode(currentNode.previousSibling) + '\\n';\n  }\n  content += spacer + describeRNode(currentNode) + `  ${AT_THIS_LOCATION}\\n`;\n  if (node.nextSibling) {\n    content += spacer + '…\\n';\n  }\n  if (node.parentNode) {\n    content = describeRNode(currentNode.parentNode as Node, '\\n' + content);\n  }\n  return content;\n}\n\n/**\n * Shortens the description of a given RNode by its type for readability\n *\n * @param nodeType the type of node\n * @param tagName the node tag name\n * @param textContent the text content in the node\n * @returns string\n */\nfunction shortRNodeDescription(\n    nodeType: number, tagName: string|null, textContent: string|null): string {\n  switch (nodeType) {\n    case Node.ELEMENT_NODE:\n      return `<${tagName!.toLowerCase()}>`;\n    case Node.TEXT_NODE:\n      const content = textContent ? ` (with the \"${shorten(textContent)}\" content)` : '';\n      return `a text node${content}`;\n    case Node.COMMENT_NODE:\n      return 'a comment node';\n    default:\n      return `#node(nodeType=${nodeType})`;\n  }\n}\n\n\n/**\n * Builds the footer hydration error message\n *\n * @param componentClassName the name of the component class\n * @returns string\n */\nfunction getHydrationErrorFooter(componentClassName?: string): string {\n  const componentInfo = componentClassName ? `the \"${componentClassName}\"` : 'corresponding';\n  return `To fix this problem:\\n` +\n      `  * check ${componentInfo} component for hydration-related issues\\n` +\n      `  * or skip hydration by adding the \\`ngSkipHydration\\` attribute ` +\n      `to its host node in a template`;\n}\n\n/**\n * An attribute related note for hydration errors\n */\nfunction getHydrationAttributeNote(): string {\n  return 'Note: attributes are only displayed to better represent the DOM' +\n      ' but have no effect on hydration mismatches.\\n\\n';\n}\n\n// Node string utility functions\n\n/**\n * Strips all newlines out of a given string\n *\n * @param input a string to be cleared of new line characters\n * @returns\n */\nfunction stripNewlines(input: string): string {\n  return input.replace(/\\s+/gm, '');\n}\n\n/**\n * Reduces a string down to a maximum length of characters with ellipsis for readability\n *\n * @param input a string input\n * @param maxLength a maximum length in characters\n * @returns string\n */\nfunction shorten(input: string|null, maxLength = 50): string {\n  if (!input) {\n    return '';\n  }\n  input = stripNewlines(input);\n  return input.length > maxLength ? `${input.substring(0, maxLength - 1)}…` : input;\n}\n"]}

package/esm2020/src/hydration/interfaces.mjs

@@ -5,6 +5,19 @@
  * 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
  */
+/** Encodes that the node lookup should start from the host node of this component. */
+export const REFERENCE_NODE_HOST = 'h';
+/** Encodes that the node lookup should start from the document body node. */
+export const REFERENCE_NODE_BODY = 'b';
+/**
+ * Describes navigation steps that the runtime logic need to perform,
+ * starting from a given (known) element.
+ */
+export var NodeNavigationStep;
+(function (NodeNavigationStep) {
+    NodeNavigationStep["FirstChild"] = "f";
+    NodeNavigationStep["NextSibling"] = "n";
+})(NodeNavigationStep || (NodeNavigationStep = {}));
 /**
  * Keys within serialized view data structure to represent various
  * parts. See the `SerializedView` interface below for additional information.
@@ -12,6 +25,9 @@
 export const ELEMENT_CONTAINERS = 'e';
 export const TEMPLATES = 't';
 export const CONTAINERS = 'c';
+export const MULTIPLIER = 'x';
 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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
+export const NODES = 'n';
+export const DISCONNECTED_NODES = 'd';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/hydration/interfaces.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,sFAAsF;AACtF,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAG,CAAC;AAEvC,6EAA6E;AAC7E,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAG,CAAC;AAEvC;;;GAGG;AACH,MAAM,CAAN,IAAY,kBAGX;AAHD,WAAY,kBAAkB;IAC5B,sCAAgB,CAAA;IAChB,uCAAiB,CAAA;AACnB,CAAC,EAHW,kBAAkB,KAAlB,kBAAkB,QAG7B;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAAG,CAAC;AACtC,MAAM,CAAC,MAAM,SAAS,GAAG,GAAG,CAAC;AAC7B,MAAM,CAAC,MAAM,UAAU,GAAG,GAAG,CAAC;AAC9B,MAAM,CAAC,MAAM,UAAU,GAAG,GAAG,CAAC;AAC9B,MAAM,CAAC,MAAM,cAAc,GAAG,GAAG,CAAC;AAClC,MAAM,CAAC,MAAM,WAAW,GAAG,GAAG,CAAC,CAAE,uBAAuB;AACxD,MAAM,CAAC,MAAM,KAAK,GAAG,GAAG,CAAC;AACzB,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAAG,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 {RNode} from '../render3/interfaces/renderer_dom';\n\n\n/** Encodes that the node lookup should start from the host node of this component. */\nexport const REFERENCE_NODE_HOST = 'h';\n\n/** Encodes that the node lookup should start from the document body node. */\nexport const REFERENCE_NODE_BODY = 'b';\n\n/**\n * Describes navigation steps that the runtime logic need to perform,\n * starting from a given (known) element.\n */\nexport enum NodeNavigationStep {\n  FirstChild = 'f',\n  NextSibling = 'n',\n}\n\n/**\n * Keys within serialized view data structure to represent various\n * parts. See the `SerializedView` interface below for additional information.\n */\nexport const ELEMENT_CONTAINERS = 'e';\nexport const TEMPLATES = 't';\nexport const CONTAINERS = 'c';\nexport const MULTIPLIER = 'x';\nexport const NUM_ROOT_NODES = 'r';\nexport const TEMPLATE_ID = 'i';  // as it's also an \"id\"\nexport const NODES = 'n';\nexport const DISCONNECTED_NODES = 'd';\n\n/**\n * Represents element containers within this view, stored as key-value pairs\n * where key is an index of a container in an LView (also used in the\n * `elementContainerStart` instruction), the value is the number of root nodes\n * in this container. This information is needed to locate an anchor comment\n * node that goes after all container nodes.\n */\nexport interface SerializedElementContainers {\n  [key: number]: number;\n}\n\n/**\n * Serialized data structure that contains relevant hydration\n * annotation information that describes a given hydration boundary\n * (e.g. a component).\n */\nexport interface SerializedView {\n  /**\n   * Serialized information about <ng-container>s.\n   */\n  [ELEMENT_CONTAINERS]?: SerializedElementContainers;\n\n  /**\n   * Serialized information about templates.\n   * Key-value pairs where a key is an index of the corresponding\n   * `template` instruction and the value is a unique id that can\n   * be used during hydration to identify that template.\n   */\n  [TEMPLATES]?: Record<number, string>;\n\n  /**\n   * Serialized information about view containers.\n   * Key-value pairs where a key is an index of the corresponding\n   * LContainer entry within an LView, and the value is a list\n   * of serialized information about views within this container.\n   */\n  [CONTAINERS]?: Record<number, SerializedContainerView[]>;\n\n  /**\n   * Serialized information about nodes in a template.\n   * Key-value pairs where a key is an index of the corresponding\n   * DOM node in an LView and the value is a path that describes\n   * the location of this node (as a set of navigation instructions).\n   */\n  [NODES]?: Record<number, string>;\n\n  /**\n   * A list of ids which represents a set of nodes disconnected\n   * from the DOM tree at the serialization time, but otherwise\n   * present in the internal data structures.\n   *\n   * This information is used to avoid triggering the hydration\n   * logic for such nodes and instead use a regular \"creation mode\".\n   */\n  [DISCONNECTED_NODES]?: number[];\n}\n\n/**\n * Serialized data structure that contains relevant hydration\n * annotation information about a view that is a part of a\n * ViewContainer collection.\n */\nexport interface SerializedContainerView extends SerializedView {\n  /**\n   * Unique id that represents a TView that was used to create\n   * a given instance of a view:\n   *  - TViewType.Embedded: a unique id generated during serialization on the server\n   *  - TViewType.Component: an id generated based on component properties\n   *                        (see `getComponentId` function for details)\n   */\n  [TEMPLATE_ID]: string;\n\n  /**\n   * Number of root nodes that belong to this view.\n   * This information is needed to effectively traverse the DOM tree\n   * and identify segments that belong to different views.\n   */\n  [NUM_ROOT_NODES]: number;\n\n  /**\n   * Number of times this view is repeated.\n   * This is used to avoid serializing and sending the same hydration\n   * information about similar views (for example, produced by *ngFor).\n   */\n  [MULTIPLIER]?: number;\n}\n\n/**\n * An object that contains hydration-related information serialized\n * on the server, as well as the necessary references to segments of\n * the DOM, to facilitate the hydration process for a given hydration\n * boundary on the client.\n */\nexport interface DehydratedView {\n  /**\n   * The readonly hydration annotation data.\n   */\n  data: Readonly<SerializedView>;\n\n  /**\n   * A reference to the first child in a DOM segment associated\n   * with a given hydration boundary.\n   */\n  firstChild: RNode|null;\n\n  /**\n   * Stores references to first nodes in DOM segments that\n   * represent either an <ng-container> or a view container.\n   */\n  segmentHeads?: {[index: number]: RNode|null};\n\n  /**\n   * An instance of a Set that represents nodes disconnected from\n   * the DOM tree at the serialization time, but otherwise present\n   * in the internal data structures.\n   *\n   * The Set is based on the `SerializedView[DISCONNECTED_NODES]` data\n   * and is needed to have constant-time lookups.\n   *\n   * If the value is `null`, it means that there were no disconnected\n   * nodes detected in this view at serialization time.\n   */\n  disconnectedNodes?: Set<number>|null;\n}\n\n/**\n * An object that contains hydration-related information serialized\n * on the server, as well as the necessary references to segments of\n * the DOM, to facilitate the hydration process for a given view\n * inside a view container (either an embedded view or a view created\n * for a component).\n */\nexport interface DehydratedContainerView extends DehydratedView {\n  data: Readonly<SerializedContainerView>;\n}\n"]}