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

package/esm2020/src/hydration/compression.mjs

@@ -0,0 +1,69 @@
+/**
+ * @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 { REFERENCE_NODE_BODY, REFERENCE_NODE_HOST } from './interfaces';
+/**
+ * Regexp that extracts a reference node information from the compressed node location.
+ * The reference node is represented as either:
+ *  - a number which points to an LView slot
+ *  - the `b` char which indicates that the lookup should start from the `document.body`
+ *  - the `h` char to start lookup from the component host node (`lView[HOST]`)
+ */
+const REF_EXTRACTOR_REGEXP = new RegExp(`^(\\d+)*(${REFERENCE_NODE_BODY}|${REFERENCE_NODE_HOST})*(.*)`);
+/**
+ * Helper function that takes a reference node location and a set of navigation steps
+ * (from the reference node) to a target node and outputs a string that represents
+ * a location.
+ *
+ * For example, given: referenceNode = 'b' (body) and path = ['firstChild', 'firstChild',
+ * 'nextSibling'], the function returns: `bf2n`.
+ */
+export function compressNodeLocation(referenceNode, path) {
+    const result = [referenceNode];
+    for (const segment of path) {
+        const lastIdx = result.length - 1;
+        if (lastIdx > 0 && result[lastIdx - 1] === segment) {
+            // An empty string in a count slot represents 1 occurrence of an instruction.
+            const value = (result[lastIdx] || 1);
+            result[lastIdx] = value + 1;
+        }
+        else {
+            // Adding a new segment to the path.
+            // Using an empty string in a counter field to avoid encoding `1`s
+            // into the path, since they are implicit (e.g. `f1n1` vs `fn`), so
+            // it's enough to have a single char in this case.
+            result.push(segment, '');
+        }
+    }
+    return result.join('');
+}
+/**
+ * Helper function that reverts the `compressNodeLocation` and transforms a given
+ * string into an array where at 0th position there is a reference node info and
+ * after that it contains information (in pairs) about a navigation step and the
+ * number of repetitions.
+ *
+ * For example, the path like 'bf2n' will be transformed to:
+ * ['b', 'firstChild', 2, 'nextSibling', 1].
+ *
+ * This information is later consumed by the code that navigates the DOM to find
+ * a given node by its location.
+ */
+export function decompressNodeLocation(path) {
+    const matches = path.match(REF_EXTRACTOR_REGEXP);
+    const [_, refNodeId, refNodeName, rest] = matches;
+    // If a reference node is represented by an index, transform it to a number.
+    const ref = refNodeId ? parseInt(refNodeId, 10) : refNodeName;
+    const steps = [];
+    // Match all segments in a path.
+    for (const [_, step, count] of rest.matchAll(/(f|n)(\d*)/g)) {
+        const repeat = parseInt(count, 10) || 1;
+        steps.push(step, repeat);
+    }
+    return [ref, ...steps];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/hydration/error_handling.mjs

@@ -5,25 +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
+ */
+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) {
-    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.`);
+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) {
+        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,29 @@
  * 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. */
+/** 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.
+ */
 export const ELEMENT_CONTAINERS = 'e';
-//# sourceMappingURL=data:application/json;base64,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
+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"
+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"]}