/**
 * @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 { ɵwithHttpTransferCache as withHttpTransferCache } from '@angular/common/http';
import { ENVIRONMENT_INITIALIZER, inject, makeEnvironmentProviders, NgZone, ɵConsole as Console, ɵformatRuntimeError as formatRuntimeError, ɵwithDomHydration as withDomHydration } from '@angular/core';
/**
 * Helper function to create an object that represents a Hydration feature.
 */
function hydrationFeature(kind, providers = []) {
    return { ɵkind: kind, ɵproviders: providers };
}
/**
 * Disables DOM nodes reuse during hydration. Effectively makes
 * Angular re-render an application from scratch on the client.
 *
 * When this option is enabled, make sure that the initial navigation
 * option is configured for the Router as `enabledBlocking` by using the
 * `withEnabledBlockingInitialNavigation` in the `provideRouter` call:
 *
 * ```
 * bootstrapApplication(RootComponent, {
 *   providers: [
 *     provideRouter(
 *       // ... other features ...
 *       withEnabledBlockingInitialNavigation()
 *     ),
 *     provideClientHydration(withNoDomReuse())
 *   ]
 * });
 * ```
 *
 * This would ensure that the application is rerendered after all async
 * operations in the Router (such as lazy-loading of components,
 * waiting for async guards and resolvers) are completed to avoid
 * clearing the DOM on the client too soon, thus causing content flicker.
 *
 * @see {@link provideRouter}
 * @see {@link withEnabledBlockingInitialNavigation}
 *
 * @publicApi
 * @developerPreview
 */
export function withNoDomReuse() {
    // This feature has no providers and acts as a flag that turns off
    // non-destructive hydration (which otherwise is turned on by default).
    return hydrationFeature(0 /* HydrationFeatureKind.NoDomReuseFeature */);
}
/**
 * Disables HTTP transfer cache. Effectively causes HTTP requests to be performed twice: once on the
 * server and other one on the browser.
 *
 * @publicApi
 * @developerPreview
 */
export function withNoHttpTransferCache() {
    // This feature has no providers and acts as a flag that turns off
    // HTTP transfer cache (which otherwise is turned on by default).
    return hydrationFeature(1 /* HydrationFeatureKind.NoHttpTransferCache */);
}
/**
 * Returns an `ENVIRONMENT_INITIALIZER` token setup with a function
 * that verifies whether compatible ZoneJS was used in an application
 * and logs a warning in a console if it's not the case.
 */
function provideZoneJsCompatibilityDetector() {
    return [{
            provide: ENVIRONMENT_INITIALIZER,
            useValue: () => {
                const ngZone = inject(NgZone);
                // Checking `ngZone instanceof NgZone` would be insufficient here,
                // because custom implementations might use NgZone as a base class.
                if (ngZone.constructor !== NgZone) {
                    const console = inject(Console);
                    const message = formatRuntimeError(-5000 /* RuntimeErrorCode.UNSUPPORTED_ZONEJS_INSTANCE */, 'Angular detected that hydration was enabled for an application ' +
                        'that uses a custom or a noop Zone.js implementation. ' +
                        'This is not yet a fully supported configuration.');
                    // tslint:disable-next-line:no-console
                    console.warn(message);
                }
            },
            multi: true,
        }];
}
/**
 * Sets up providers necessary to enable hydration functionality for the application.
 *
 * By default, the function enables the recommended set of features for the optimal
 * performance for most of the applications. You can enable/disable features by
 * passing special functions (from the `HydrationFeatures` set) as arguments to the
 * `provideClientHydration` function. It includes the following features:
 *
 * * Reconciling DOM hydration. Learn more about it [here](guide/hydration).
 * * [`HttpClient`](api/common/http/HttpClient) response caching while running on the server and
 * transferring this cache to the client to avoid extra HTTP requests. Learn more about data caching
 * [here](/guide/universal#caching-data-when-using-httpclient).
 *
 * These functions functions will allow you to disable some of the default features:
 * * {@link withNoDomReuse} to disable DOM nodes reuse during hydration
 * * {@link withNoHttpTransferCache} to disable HTTP transfer cache
 *
 *
 * @usageNotes
 *
 * Basic example of how you can enable hydration in your application when
 * `bootstrapApplication` function is used:
 * ```
 * bootstrapApplication(AppComponent, {
 *   providers: [provideClientHydration()]
 * });
 * ```
 *
 * Alternatively if you are using NgModules, you would add `provideClientHydration`
 * to your root app module's provider list.
 * ```
 * @NgModule({
 *   declarations: [RootCmp],
 *   bootstrap: [RootCmp],
 *   providers: [provideClientHydration()],
 * })
 * export class AppModule {}
 * ```
 *
 * @see {@link withNoDomReuse}
 * @see {@link withNoHttpTransferCache}
 *
 * @param features Optional features to configure additional router behaviors.
 * @returns A set of providers to enable hydration.
 *
 * @publicApi
 * @developerPreview
 */
export function provideClientHydration(...features) {
    const providers = [];
    const featuresKind = new Set();
    for (const { ɵproviders, ɵkind } of features) {
        featuresKind.add(ɵkind);
        if (ɵproviders.length) {
            providers.push(ɵproviders);
        }
    }
    return makeEnvironmentProviders([
        (typeof ngDevMode !== 'undefined' && ngDevMode) ? provideZoneJsCompatibilityDetector() : [],
        (featuresKind.has(0 /* HydrationFeatureKind.NoDomReuseFeature */) ? [] : withDomHydration()),
        (featuresKind.has(1 /* HydrationFeatureKind.NoHttpTransferCache */) ? [] : withHttpTransferCache()),
        providers,
    ]);
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hydration.js","sourceRoot":"","sources":["../../../../../../packages/platform-browser/src/hydration.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,sBAAsB,IAAI,qBAAqB,EAAC,MAAM,sBAAsB,CAAC;AACrF,OAAO,EAAC,uBAAuB,EAAwB,MAAM,EAAE,wBAAwB,EAAE,MAAM,EAAY,QAAQ,IAAI,OAAO,EAAE,mBAAmB,IAAI,kBAAkB,EAAE,iBAAiB,IAAI,gBAAgB,EAAC,MAAM,eAAe,CAAC;AA2BvO;;GAEG;AACH,SAAS,gBAAgB,CACrB,IAAiB,EAAE,YAAwB,EAAE;IAC/C,OAAO,EAAC,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAC,CAAC;AAC9C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,UAAU,cAAc;IAC5B,kEAAkE;IAClE,uEAAuE;IACvE,OAAO,gBAAgB,gDAAwC,CAAC;AAClE,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB;IAErC,kEAAkE;IAClE,iEAAiE;IACjE,OAAO,gBAAgB,kDAA0C,CAAC;AACpE,CAAC;AAED;;;;GAIG;AACH,SAAS,kCAAkC;IACzC,OAAO,CAAC;YACN,OAAO,EAAE,uBAAuB;YAChC,QAAQ,EAAE,GAAG,EAAE;gBACb,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;gBAC9B,kEAAkE;gBAClE,mEAAmE;gBACnE,IAAI,MAAM,CAAC,WAAW,KAAK,MAAM,EAAE;oBACjC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;oBAChC,MAAM,OAAO,GAAG,kBAAkB,2DAE9B,iEAAiE;wBAC7D,uDAAuD;wBACvD,kDAAkD,CAAC,CAAC;oBAC5D,sCAAsC;oBACtC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;iBACvB;YACH,CAAC;YACD,KAAK,EAAE,IAAI;SACZ,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,MAAM,UAAU,sBAAsB,CAAC,GAAG,QAAkD;IAE1F,MAAM,SAAS,GAAe,EAAE,CAAC;IACjC,MAAM,YAAY,GAAG,IAAI,GAAG,EAAwB,CAAC;IAErD,KAAK,MAAM,EAAC,UAAU,EAAE,KAAK,EAAC,IAAI,QAAQ,EAAE;QAC1C,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAExB,IAAI,UAAU,CAAC,MAAM,EAAE;YACrB,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;SAC5B;KACF;IACD,OAAO,wBAAwB,CAAC;QAC9B,CAAC,OAAO,SAAS,KAAK,WAAW,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,kCAAkC,EAAE,CAAC,CAAC,CAAC,EAAE;QAC3F,CAAC,YAAY,CAAC,GAAG,gDAAwC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,EAAE,CAAC;QACpF,CAAC,YAAY,CAAC,GAAG,kDAA0C,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,qBAAqB,EAAE,CAAC;QAC3F,SAAS;KACV,CAAC,CAAC;AACL,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 {ɵwithHttpTransferCache as withHttpTransferCache} from '@angular/common/http';\nimport {ENVIRONMENT_INITIALIZER, EnvironmentProviders, inject, makeEnvironmentProviders, NgZone, Provider, ɵConsole as Console, ɵformatRuntimeError as formatRuntimeError, ɵwithDomHydration as withDomHydration} from '@angular/core';\n\nimport {RuntimeErrorCode} from './errors';\n\n/**\n * The list of features as an enum to uniquely type each `HydrationFeature`.\n * @see {@link HydrationFeature}\n *\n * @publicApi\n * @developerPreview\n */\nexport const enum HydrationFeatureKind {\n  NoDomReuseFeature,\n  NoHttpTransferCache\n}\n\n/**\n * Helper type to represent a Hydration feature.\n *\n * @publicApi\n * @developerPreview\n */\nexport interface HydrationFeature<FeatureKind extends HydrationFeatureKind> {\n  ɵkind: FeatureKind;\n  ɵproviders: Provider[];\n}\n\n/**\n * Helper function to create an object that represents a Hydration feature.\n */\nfunction hydrationFeature<FeatureKind extends HydrationFeatureKind>(\n    kind: FeatureKind, providers: Provider[] = []): HydrationFeature<FeatureKind> {\n  return {ɵkind: kind, ɵproviders: providers};\n}\n\n/**\n * Disables DOM nodes reuse during hydration. Effectively makes\n * Angular re-render an application from scratch on the client.\n *\n * When this option is enabled, make sure that the initial navigation\n * option is configured for the Router as `enabledBlocking` by using the\n * `withEnabledBlockingInitialNavigation` in the `provideRouter` call:\n *\n * ```\n * bootstrapApplication(RootComponent, {\n *   providers: [\n *     provideRouter(\n *       // ... other features ...\n *       withEnabledBlockingInitialNavigation()\n *     ),\n *     provideClientHydration(withNoDomReuse())\n *   ]\n * });\n * ```\n *\n * This would ensure that the application is rerendered after all async\n * operations in the Router (such as lazy-loading of components,\n * waiting for async guards and resolvers) are completed to avoid\n * clearing the DOM on the client too soon, thus causing content flicker.\n *\n * @see {@link provideRouter}\n * @see {@link withEnabledBlockingInitialNavigation}\n *\n * @publicApi\n * @developerPreview\n */\nexport function withNoDomReuse(): HydrationFeature<HydrationFeatureKind.NoDomReuseFeature> {\n  // This feature has no providers and acts as a flag that turns off\n  // non-destructive hydration (which otherwise is turned on by default).\n  return hydrationFeature(HydrationFeatureKind.NoDomReuseFeature);\n}\n\n/**\n * Disables HTTP transfer cache. Effectively causes HTTP requests to be performed twice: once on the\n * server and other one on the browser.\n *\n * @publicApi\n * @developerPreview\n */\nexport function withNoHttpTransferCache():\n    HydrationFeature<HydrationFeatureKind.NoHttpTransferCache> {\n  // This feature has no providers and acts as a flag that turns off\n  // HTTP transfer cache (which otherwise is turned on by default).\n  return hydrationFeature(HydrationFeatureKind.NoHttpTransferCache);\n}\n\n/**\n * Returns an `ENVIRONMENT_INITIALIZER` token setup with a function\n * that verifies whether compatible ZoneJS was used in an application\n * and logs a warning in a console if it's not the case.\n */\nfunction provideZoneJsCompatibilityDetector(): Provider[] {\n  return [{\n    provide: ENVIRONMENT_INITIALIZER,\n    useValue: () => {\n      const ngZone = inject(NgZone);\n      // Checking `ngZone instanceof NgZone` would be insufficient here,\n      // because custom implementations might use NgZone as a base class.\n      if (ngZone.constructor !== NgZone) {\n        const console = inject(Console);\n        const message = formatRuntimeError(\n            RuntimeErrorCode.UNSUPPORTED_ZONEJS_INSTANCE,\n            'Angular detected that hydration was enabled for an application ' +\n                'that uses a custom or a noop Zone.js implementation. ' +\n                'This is not yet a fully supported configuration.');\n        // tslint:disable-next-line:no-console\n        console.warn(message);\n      }\n    },\n    multi: true,\n  }];\n}\n\n/**\n * Sets up providers necessary to enable hydration functionality for the application.\n *\n * By default, the function enables the recommended set of features for the optimal\n * performance for most of the applications. You can enable/disable features by\n * passing special functions (from the `HydrationFeatures` set) as arguments to the\n * `provideClientHydration` function. It includes the following features:\n *\n * * Reconciling DOM hydration. Learn more about it [here](guide/hydration).\n * * [`HttpClient`](api/common/http/HttpClient) response caching while running on the server and\n * transferring this cache to the client to avoid extra HTTP requests. Learn more about data caching\n * [here](/guide/universal#caching-data-when-using-httpclient).\n *\n * These functions functions will allow you to disable some of the default features:\n * * {@link withNoDomReuse} to disable DOM nodes reuse during hydration\n * * {@link withNoHttpTransferCache} to disable HTTP transfer cache\n *\n *\n * @usageNotes\n *\n * Basic example of how you can enable hydration in your application when\n * `bootstrapApplication` function is used:\n * ```\n * bootstrapApplication(AppComponent, {\n *   providers: [provideClientHydration()]\n * });\n * ```\n *\n * Alternatively if you are using NgModules, you would add `provideClientHydration`\n * to your root app module's provider list.\n * ```\n * @NgModule({\n *   declarations: [RootCmp],\n *   bootstrap: [RootCmp],\n *   providers: [provideClientHydration()],\n * })\n * export class AppModule {}\n * ```\n *\n * @see {@link withNoDomReuse}\n * @see {@link withNoHttpTransferCache}\n *\n * @param features Optional features to configure additional router behaviors.\n * @returns A set of providers to enable hydration.\n *\n * @publicApi\n * @developerPreview\n */\nexport function provideClientHydration(...features: HydrationFeature<HydrationFeatureKind>[]):\n    EnvironmentProviders {\n  const providers: Provider[] = [];\n  const featuresKind = new Set<HydrationFeatureKind>();\n\n  for (const {ɵproviders, ɵkind} of features) {\n    featuresKind.add(ɵkind);\n\n    if (ɵproviders.length) {\n      providers.push(ɵproviders);\n    }\n  }\n  return makeEnvironmentProviders([\n    (typeof ngDevMode !== 'undefined' && ngDevMode) ? provideZoneJsCompatibilityDetector() : [],\n    (featuresKind.has(HydrationFeatureKind.NoDomReuseFeature) ? [] : withDomHydration()),\n    (featuresKind.has(HydrationFeatureKind.NoHttpTransferCache) ? [] : withHttpTransferCache()),\n    providers,\n  ]);\n}\n"]}