@angular/core
Version:
Angular - the core framework
223 lines • 32 kB
JavaScript
/**
* @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 { APP_BOOTSTRAP_LISTENER, ApplicationRef, whenStable } from '../application_ref';
import { Console } from '../console';
import { ENVIRONMENT_INITIALIZER, Injector, makeEnvironmentProviders } from '../di';
import { inject } from '../di/injector_compatibility';
import { formatRuntimeError, RuntimeError } from '../errors';
import { enableLocateOrCreateContainerRefImpl } from '../linker/view_container_ref';
import { enableLocateOrCreateElementNodeImpl } from '../render3/instructions/element';
import { enableLocateOrCreateElementContainerNodeImpl } from '../render3/instructions/element_container';
import { enableApplyRootElementTransformImpl } from '../render3/instructions/shared';
import { enableLocateOrCreateContainerAnchorImpl } from '../render3/instructions/template';
import { enableLocateOrCreateTextNodeImpl } from '../render3/instructions/text';
import { getDocument } from '../render3/interfaces/document';
import { isPlatformBrowser } from '../render3/util/misc_utils';
import { TransferState } from '../transfer_state';
import { performanceMark } from '../util/performance';
import { NgZone } from '../zone';
import { cleanupDehydratedViews } from './cleanup';
import { IS_HYDRATION_DOM_REUSE_ENABLED, PRESERVE_HOST_CONTENT } from './tokens';
import { enableRetrieveHydrationInfoImpl, NGH_DATA_KEY, SSR_CONTENT_INTEGRITY_MARKER } from './utils';
import { enableFindMatchingDehydratedViewImpl } from './views';
/**
* Indicates whether the hydration-related code was added,
* prevents adding it multiple times.
*/
let isHydrationSupportEnabled = false;
/**
* Defines a period of time that Angular waits for the `ApplicationRef.isStable` to emit `true`.
* If there was no event with the `true` value during this time, Angular reports a warning.
*/
const APPLICATION_IS_STABLE_TIMEOUT = 10000;
/**
* Brings the necessary hydration code in tree-shakable manner.
* The code is only present when the `provideClientHydration` 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();
enableLocateOrCreateContainerAnchorImpl();
enableLocateOrCreateContainerRefImpl();
enableFindMatchingDehydratedViewImpl();
enableApplyRootElementTransformImpl();
}
}
/**
* Outputs a message with hydration stats into a console.
*/
function printHydrationStats(injector) {
const console = injector.get(Console);
const message = `Angular hydrated ${ngDevMode.hydratedComponents} component(s) ` +
`and ${ngDevMode.hydratedNodes} node(s), ` +
`${ngDevMode.componentsSkippedHydration} component(s) were skipped. ` +
`Learn more at https://angular.io/guide/hydration.`;
// tslint:disable-next-line:no-console
console.log(message);
}
/**
* Returns a Promise that is resolved when an application becomes stable.
*/
function whenStableWithTimeout(appRef, injector) {
const whenStablePromise = whenStable(appRef);
if (typeof ngDevMode !== 'undefined' && ngDevMode) {
const timeoutTime = APPLICATION_IS_STABLE_TIMEOUT;
const console = injector.get(Console);
const ngZone = injector.get(NgZone);
// The following call should not and does not prevent the app to become stable
// We cannot use RxJS timer here because the app would remain unstable.
// This also avoids an extra change detection cycle.
const timeoutId = ngZone.runOutsideAngular(() => {
return setTimeout(() => logWarningOnStableTimedout(timeoutTime, console), timeoutTime);
});
whenStablePromise.finally(() => clearTimeout(timeoutId));
}
return whenStablePromise;
}
/**
* Returns a set of providers required to setup hydration support
* for an application that is server side rendered. This function is
* included into the `provideClientHydration` public API function from
* the `platform-browser` package.
*
* 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.
*/
export function withDomHydration() {
return makeEnvironmentProviders([
{
provide: IS_HYDRATION_DOM_REUSE_ENABLED,
useFactory: () => {
let isEnabled = true;
if (isPlatformBrowser()) {
// On the client, verify that the server response contains
// hydration annotations. Otherwise, keep hydration disabled.
const transferState = inject(TransferState, { optional: true });
isEnabled = !!transferState?.get(NGH_DATA_KEY, null);
if (!isEnabled && (typeof ngDevMode !== 'undefined' && ngDevMode)) {
const console = inject(Console);
const message = formatRuntimeError(-505 /* RuntimeErrorCode.MISSING_HYDRATION_ANNOTATIONS */, 'Angular hydration was requested on the client, but there was no ' +
'serialized information present in the server response, ' +
'thus hydration was not enabled. ' +
'Make sure the `provideClientHydration()` is included into the list ' +
'of providers in the server part of the application configuration.');
// tslint:disable-next-line:no-console
console.warn(message);
}
}
if (isEnabled) {
performanceMark('mark_use_counter', { detail: { feature: 'NgHydration' } });
}
return isEnabled;
},
},
{
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 `isPlatformBrowser` check should
// be replaced with a tree-shakable alternative (e.g. `isServer`
// flag).
if (isPlatformBrowser() && inject(IS_HYDRATION_DOM_REUSE_ENABLED)) {
verifySsrContentsIntegrity();
enableHydrationRuntimeSupport();
}
},
multi: true,
},
{
provide: PRESERVE_HOST_CONTENT,
useFactory: () => {
// Preserve host element content only in a browser
// environment and when hydration is configured properly.
// On a server, an application is rendered from scratch,
// so the host content needs to be empty.
return isPlatformBrowser() && inject(IS_HYDRATION_DOM_REUSE_ENABLED);
}
},
{
provide: APP_BOOTSTRAP_LISTENER,
useFactory: () => {
if (isPlatformBrowser() && inject(IS_HYDRATION_DOM_REUSE_ENABLED)) {
const appRef = inject(ApplicationRef);
const injector = inject(Injector);
return () => {
// Wait until an app becomes stable and cleanup all views that
// were not claimed during the application bootstrap process.
// The timing is similar to when we start the serialization process
// on the server.
//
// Note: the cleanup task *MUST* be scheduled within the Angular zone
// to ensure that change detection is properly run afterward.
whenStableWithTimeout(appRef, injector).then(() => {
NgZone.assertInAngularZone();
cleanupDehydratedViews(appRef);
if (typeof ngDevMode !== 'undefined' && ngDevMode) {
printHydrationStats(injector);
}
});
};
}
return () => { }; // noop
},
multi: true,
}
]);
}
/**
*
* @param time The time in ms until the stable timedout warning message is logged
*/
function logWarningOnStableTimedout(time, console) {
const message = `Angular hydration expected the ApplicationRef.isStable() to emit \`true\`, but it ` +
`didn't happen within ${time}ms. Angular hydration logic depends on the application becoming stable ` +
`as a signal to complete hydration process.`;
console.warn(formatRuntimeError(-506 /* RuntimeErrorCode.HYDRATION_STABLE_TIMEDOUT */, message));
}
/**
* Verifies whether the DOM contains a special marker added during SSR time to make sure
* there is no SSR'ed contents transformations happen after SSR is completed. Typically that
* happens either by CDN or during the build process as an optimization to remove comment nodes.
* Hydration process requires comment nodes produced by Angular to locate correct DOM segments.
* When this special marker is *not* present - throw an error and do not proceed with hydration,
* since it will not be able to function correctly.
*
* Note: this function is invoked only on the client, so it's safe to use DOM APIs.
*/
function verifySsrContentsIntegrity() {
const doc = getDocument();
let hydrationMarker;
for (const node of doc.body.childNodes) {
if (node.nodeType === Node.COMMENT_NODE &&
node.textContent?.trim() === SSR_CONTENT_INTEGRITY_MARKER) {
hydrationMarker = node;
break;
}
}
if (!hydrationMarker) {
throw new RuntimeError(-507 /* RuntimeErrorCode.MISSING_SSR_CONTENT_INTEGRITY_MARKER */, typeof ngDevMode !== 'undefined' && ngDevMode &&
'Angular hydration logic detected that HTML content of this page was modified after it ' +
'was produced during server side rendering. Make sure that there are no optimizations ' +
'that remove comment nodes from HTML enabled on your CDN. Angular hydration ' +
'relies on HTML produced by the server, including whitespaces and comment nodes.');
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/hydration/api.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 {APP_BOOTSTRAP_LISTENER, ApplicationRef, whenStable} from '../application_ref';\nimport {Console} from '../console';\nimport {ENVIRONMENT_INITIALIZER, EnvironmentProviders, Injector, makeEnvironmentProviders} from '../di';\nimport {inject} from '../di/injector_compatibility';\nimport {formatRuntimeError, RuntimeError, RuntimeErrorCode} from '../errors';\nimport {enableLocateOrCreateContainerRefImpl} from '../linker/view_container_ref';\nimport {enableLocateOrCreateElementNodeImpl} from '../render3/instructions/element';\nimport {enableLocateOrCreateElementContainerNodeImpl} from '../render3/instructions/element_container';\nimport {enableApplyRootElementTransformImpl} from '../render3/instructions/shared';\nimport {enableLocateOrCreateContainerAnchorImpl} from '../render3/instructions/template';\nimport {enableLocateOrCreateTextNodeImpl} from '../render3/instructions/text';\nimport {getDocument} from '../render3/interfaces/document';\nimport {isPlatformBrowser} from '../render3/util/misc_utils';\nimport {TransferState} from '../transfer_state';\nimport {performanceMark} from '../util/performance';\nimport {NgZone} from '../zone';\n\nimport {cleanupDehydratedViews} from './cleanup';\nimport {IS_HYDRATION_DOM_REUSE_ENABLED, PRESERVE_HOST_CONTENT} from './tokens';\nimport {enableRetrieveHydrationInfoImpl, NGH_DATA_KEY, SSR_CONTENT_INTEGRITY_MARKER} from './utils';\nimport {enableFindMatchingDehydratedViewImpl} from './views';\n\n/**\n * Indicates whether the hydration-related code was added,\n * prevents adding it multiple times.\n */\nlet isHydrationSupportEnabled = false;\n\n/**\n * Defines a period of time that Angular waits for the `ApplicationRef.isStable` to emit `true`.\n * If there was no event with the `true` value during this time, Angular reports a warning.\n */\nconst APPLICATION_IS_STABLE_TIMEOUT = 10_000;\n\n/**\n * Brings the necessary hydration code in tree-shakable manner.\n * The code is only present when the `provideClientHydration` is\n * invoked. Otherwise, this code is tree-shaken away during the\n * build optimization step.\n *\n * This technique allows us to swap implementations of methods so\n * tree shaking works appropriately when hydration is disabled or\n * enabled. It brings in the appropriate version of the method that\n * supports hydration only when enabled.\n */\nfunction enableHydrationRuntimeSupport() {\n  if (!isHydrationSupportEnabled) {\n    isHydrationSupportEnabled = true;\n    enableRetrieveHydrationInfoImpl();\n    enableLocateOrCreateElementNodeImpl();\n    enableLocateOrCreateTextNodeImpl();\n    enableLocateOrCreateElementContainerNodeImpl();\n    enableLocateOrCreateContainerAnchorImpl();\n    enableLocateOrCreateContainerRefImpl();\n    enableFindMatchingDehydratedViewImpl();\n    enableApplyRootElementTransformImpl();\n  }\n}\n\n/**\n * Outputs a message with hydration stats into a console.\n */\nfunction printHydrationStats(injector: Injector) {\n  const console = injector.get(Console);\n  const message = `Angular hydrated ${ngDevMode!.hydratedComponents} component(s) ` +\n      `and ${ngDevMode!.hydratedNodes} node(s), ` +\n      `${ngDevMode!.componentsSkippedHydration} component(s) were skipped. ` +\n      `Learn more at https://angular.io/guide/hydration.`;\n  // tslint:disable-next-line:no-console\n  console.log(message);\n}\n\n\n/**\n * Returns a Promise that is resolved when an application becomes stable.\n */\nfunction whenStableWithTimeout(appRef: ApplicationRef, injector: Injector): Promise<void> {\n  const whenStablePromise = whenStable(appRef);\n  if (typeof ngDevMode !== 'undefined' && ngDevMode) {\n    const timeoutTime = APPLICATION_IS_STABLE_TIMEOUT;\n    const console = injector.get(Console);\n    const ngZone = injector.get(NgZone);\n\n    // The following call should not and does not prevent the app to become stable\n    // We cannot use RxJS timer here because the app would remain unstable.\n    // This also avoids an extra change detection cycle.\n    const timeoutId = ngZone.runOutsideAngular(() => {\n      return setTimeout(() => logWarningOnStableTimedout(timeoutTime, console), timeoutTime);\n    });\n\n    whenStablePromise.finally(() => clearTimeout(timeoutId));\n  }\n\n  return whenStablePromise;\n}\n\n/**\n * Returns a set of providers required to setup hydration support\n * for an application that is server side rendered. This function is\n * included into the `provideClientHydration` public API function from\n * the `platform-browser` package.\n *\n * The function sets up an internal flag that would be recognized during\n * the server side rendering time as well, so there is no need to\n * configure or change anything in NgUniversal to enable the feature.\n */\nexport function withDomHydration(): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    {\n      provide: IS_HYDRATION_DOM_REUSE_ENABLED,\n      useFactory: () => {\n        let isEnabled = true;\n        if (isPlatformBrowser()) {\n          // On the client, verify that the server response contains\n          // hydration annotations. Otherwise, keep hydration disabled.\n          const transferState = inject(TransferState, {optional: true});\n          isEnabled = !!transferState?.get(NGH_DATA_KEY, null);\n          if (!isEnabled && (typeof ngDevMode !== 'undefined' && ngDevMode)) {\n            const console = inject(Console);\n            const message = formatRuntimeError(\n                RuntimeErrorCode.MISSING_HYDRATION_ANNOTATIONS,\n                'Angular hydration was requested on the client, but there was no ' +\n                    'serialized information present in the server response, ' +\n                    'thus hydration was not enabled. ' +\n                    'Make sure the `provideClientHydration()` is included into the list ' +\n                    'of providers in the server part of the application configuration.');\n            // tslint:disable-next-line:no-console\n            console.warn(message);\n          }\n        }\n        if (isEnabled) {\n          performanceMark('mark_use_counter', {detail: {feature: 'NgHydration'}});\n        }\n        return isEnabled;\n      },\n    },\n    {\n      provide: ENVIRONMENT_INITIALIZER,\n      useValue: () => {\n        // Since this function is used across both server and client,\n        // make sure that the runtime code is only added when invoked\n        // on the client. Moving forward, the `isPlatformBrowser` check should\n        // be replaced with a tree-shakable alternative (e.g. `isServer`\n        // flag).\n        if (isPlatformBrowser() && inject(IS_HYDRATION_DOM_REUSE_ENABLED)) {\n          verifySsrContentsIntegrity();\n          enableHydrationRuntimeSupport();\n        }\n      },\n      multi: true,\n    },\n    {\n      provide: PRESERVE_HOST_CONTENT,\n      useFactory: () => {\n        // Preserve host element content only in a browser\n        // environment and when hydration is configured properly.\n        // On a server, an application is rendered from scratch,\n        // so the host content needs to be empty.\n        return isPlatformBrowser() && inject(IS_HYDRATION_DOM_REUSE_ENABLED);\n      }\n    },\n    {\n      provide: APP_BOOTSTRAP_LISTENER,\n      useFactory: () => {\n        if (isPlatformBrowser() && inject(IS_HYDRATION_DOM_REUSE_ENABLED)) {\n          const appRef = inject(ApplicationRef);\n          const injector = inject(Injector);\n          return () => {\n            // Wait until an app becomes stable and cleanup all views that\n            // were not claimed during the application bootstrap process.\n            // The timing is similar to when we start the serialization process\n            // on the server.\n            //\n            // Note: the cleanup task *MUST* be scheduled within the Angular zone\n            // to ensure that change detection is properly run afterward.\n            whenStableWithTimeout(appRef, injector).then(() => {\n              NgZone.assertInAngularZone();\n              cleanupDehydratedViews(appRef);\n\n              if (typeof ngDevMode !== 'undefined' && ngDevMode) {\n                printHydrationStats(injector);\n              }\n            });\n          };\n        }\n        return () => {};  // noop\n      },\n      multi: true,\n    }\n  ]);\n}\n\n/**\n *\n * @param time The time in ms until the stable timedout warning message is logged\n */\nfunction logWarningOnStableTimedout(time: number, console: Console): void {\n  const message =\n      `Angular hydration expected the ApplicationRef.isStable() to emit \\`true\\`, but it ` +\n      `didn't happen within ${\n          time}ms. Angular hydration logic depends on the application becoming stable ` +\n      `as a signal to complete hydration process.`;\n\n  console.warn(formatRuntimeError(RuntimeErrorCode.HYDRATION_STABLE_TIMEDOUT, message));\n}\n\n/**\n * Verifies whether the DOM contains a special marker added during SSR time to make sure\n * there is no SSR'ed contents transformations happen after SSR is completed. Typically that\n * happens either by CDN or during the build process as an optimization to remove comment nodes.\n * Hydration process requires comment nodes produced by Angular to locate correct DOM segments.\n * When this special marker is *not* present - throw an error and do not proceed with hydration,\n * since it will not be able to function correctly.\n *\n * Note: this function is invoked only on the client, so it's safe to use DOM APIs.\n */\nfunction verifySsrContentsIntegrity(): void {\n  const doc = getDocument();\n  let hydrationMarker: Node|undefined;\n  for (const node of doc.body.childNodes) {\n    if (node.nodeType === Node.COMMENT_NODE &&\n        node.textContent?.trim() === SSR_CONTENT_INTEGRITY_MARKER) {\n      hydrationMarker = node;\n      break;\n    }\n  }\n  if (!hydrationMarker) {\n    throw new RuntimeError(\n        RuntimeErrorCode.MISSING_SSR_CONTENT_INTEGRITY_MARKER,\n        typeof ngDevMode !== 'undefined' && ngDevMode &&\n            'Angular hydration logic detected that HTML content of this page was modified after it ' +\n                'was produced during server side rendering. Make sure that there are no optimizations ' +\n                'that remove comment nodes from HTML enabled on your CDN. Angular hydration ' +\n                'relies on HTML produced by the server, including whitespaces and comment nodes.');\n  }\n}\n"]}