@angular/router 14.2.0-next.1 → 14.2.1

package/esm2020/src/provide_router.mjs

@@ -0,0 +1,420 @@
+/**
+ * @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 { LOCATION_INITIALIZED, ViewportScroller } from '@angular/common';
+import { APP_BOOTSTRAP_LISTENER, APP_INITIALIZER, ApplicationRef, ENVIRONMENT_INITIALIZER, inject, InjectFlags, InjectionToken, Injector } from '@angular/core';
+import { of, Subject } from 'rxjs';
+import { filter, map, take } from 'rxjs/operators';
+import { NavigationCancel, NavigationEnd, NavigationError, stringifyEvent } from './events';
+import { Router } from './router';
+import { ROUTER_CONFIGURATION } from './router_config';
+import { ROUTES } from './router_config_loader';
+import { PreloadingStrategy, RouterPreloader } from './router_preloader';
+import { ROUTER_SCROLLER, RouterScroller } from './router_scroller';
+import { ActivatedRoute } from './router_state';
+const NG_DEV_MODE = typeof ngDevMode === 'undefined' || ngDevMode;
+/**
+ * Sets up providers necessary to enable `Router` functionality for the application.
+ * Allows to configure a set of routes as well as extra features that should be enabled.
+ *
+ * @usageNotes
+ *
+ * Basic example of how you can add a Router to your application:
+ * ```
+ * const appRoutes: Routes = [];
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideRouter(appRoutes)]
+ * });
+ * ```
+ *
+ * You can also enable optional features in the Router by adding functions from the `RouterFeatures`
+ * type:
+ * ```
+ * const appRoutes: Routes = [];
+ * bootstrapApplication(AppComponent,
+ *   {
+ *     providers: [
+ *       provideRouter(appRoutes,
+ *         withDebugTracing(),
+ *         withRouterConfig({paramsInheritanceStrategy: 'always'}))
+ *     ]
+ *   }
+ * );
+ * ```
+ *
+ * @see `RouterFeatures`
+ *
+ * @publicApi
+ * @developerPreview
+ * @param routes A set of `Route`s to use for the application routing table.
+ * @param features Optional features to configure additional router behaviors.
+ * @returns A set of providers to setup a Router.
+ */
+export function provideRouter(routes, ...features) {
+    return [
+        provideRoutes(routes), { provide: ActivatedRoute, useFactory: rootRoute, deps: [Router] },
+        { provide: APP_BOOTSTRAP_LISTENER, multi: true, useFactory: getBootstrapListener },
+        features.map(feature => feature.ɵproviders),
+        // TODO: All options used by the `assignExtraOptionsToRouter` factory need to be reviewed for
+        // how we want them to be configured. This API doesn't currently have a way to configure them
+        // and we should decide what the _best_ way to do that is rather than just sticking with the
+        // status quo of how it's done today.
+    ];
+}
+export function rootRoute(router) {
+    return router.routerState.root;
+}
+/**
+ * Helper function to create an object that represents a Router feature.
+ */
+function routerFeature(kind, providers) {
+    return { ɵkind: kind, ɵproviders: providers };
+}
+/**
+ * Registers a [DI provider](guide/glossary#provider) for a set of routes.
+ * @param routes The route configuration to provide.
+ *
+ * @usageNotes
+ *
+ * ```
+ * @NgModule({
+ *   providers: [provideRoutes(ROUTES)]
+ * })
+ * class LazyLoadedChildModule {}
+ * ```
+ *
+ * @publicApi
+ */
+export function provideRoutes(routes) {
+    return [
+        { provide: ROUTES, multi: true, useValue: routes },
+    ];
+}
+/**
+ * Enables customizable scrolling behavior for router navigations.
+ *
+ * @usageNotes
+ *
+ * Basic example of how you can enable scrolling feature:
+ * ```
+ * const appRoutes: Routes = [];
+ * bootstrapApplication(AppComponent,
+ *   {
+ *     providers: [
+ *       provideRouter(appRoutes, withInMemoryScrolling())
+ *     ]
+ *   }
+ * );
+ * ```
+ *
+ * @see `provideRouter`
+ * @see `ViewportScroller`
+ *
+ * @publicApi
+ * @developerPreview
+ * @param options Set of configuration parameters to customize scrolling behavior, see
+ *     `InMemoryScrollingOptions` for additional information.
+ * @returns A set of providers for use with `provideRouter`.
+ */
+export function withInMemoryScrolling(options = {}) {
+    const providers = [{
+            provide: ROUTER_SCROLLER,
+            useFactory: () => {
+                const router = inject(Router);
+                const viewportScroller = inject(ViewportScroller);
+                return new RouterScroller(router, viewportScroller, options);
+            },
+        }];
+    return routerFeature(4 /* RouterFeatureKind.InMemoryScrollingFeature */, providers);
+}
+export function getBootstrapListener() {
+    const injector = inject(Injector);
+    return (bootstrappedComponentRef) => {
+        const ref = injector.get(ApplicationRef);
+        if (bootstrappedComponentRef !== ref.components[0]) {
+            return;
+        }
+        const router = injector.get(Router);
+        const bootstrapDone = injector.get(BOOTSTRAP_DONE);
+        if (injector.get(INITIAL_NAVIGATION) === 1 /* InitialNavigation.EnabledNonBlocking */) {
+            router.initialNavigation();
+        }
+        injector.get(ROUTER_PRELOADER, null, InjectFlags.Optional)?.setUpPreloading();
+        injector.get(ROUTER_SCROLLER, null, InjectFlags.Optional)?.init();
+        router.resetRootComponentType(ref.componentTypes[0]);
+        bootstrapDone.next();
+        bootstrapDone.complete();
+    };
+}
+/**
+ * A subject used to indicate that the bootstrapping phase is done. When initial navigation is
+ * `enabledBlocking`, the first navigation waits until bootstrapping is finished before continuing
+ * to the activation phase.
+ */
+const BOOTSTRAP_DONE = new InjectionToken(NG_DEV_MODE ? 'bootstrap done indicator' : '', {
+    factory: () => {
+        return new Subject();
+    }
+});
+const INITIAL_NAVIGATION = new InjectionToken(NG_DEV_MODE ? 'initial navigation' : '', { providedIn: 'root', factory: () => 1 /* InitialNavigation.EnabledNonBlocking */ });
+/**
+ * Configures initial navigation to start before the root component is created.
+ *
+ * The bootstrap is blocked until the initial navigation is complete. This value is required for
+ * [server-side rendering](guide/universal) to work.
+ *
+ * @usageNotes
+ *
+ * Basic example of how you can enable this navigation behavior:
+ * ```
+ * const appRoutes: Routes = [];
+ * bootstrapApplication(AppComponent,
+ *   {
+ *     providers: [
+ *       provideRouter(appRoutes, withEnabledBlockingInitialNavigation())
+ *     ]
+ *   }
+ * );
+ * ```
+ *
+ * @see `provideRouter`
+ *
+ * @publicApi
+ * @developerPreview
+ * @returns A set of providers for use with `provideRouter`.
+ */
+export function withEnabledBlockingInitialNavigation() {
+    const providers = [
+        { provide: INITIAL_NAVIGATION, useValue: 0 /* InitialNavigation.EnabledBlocking */ },
+        {
+            provide: APP_INITIALIZER,
+            multi: true,
+            deps: [Injector],
+            useFactory: (injector) => {
+                const locationInitialized = injector.get(LOCATION_INITIALIZED, Promise.resolve());
+                let initNavigation = false;
+                /**
+                 * Performs the given action once the router finishes its next/current navigation.
+                 *
+                 * If the navigation is canceled or errors without a redirect, the navigation is considered
+                 * complete. If the `NavigationEnd` event emits, the navigation is also considered complete.
+                 */
+                function afterNextNavigation(action) {
+                    const router = injector.get(Router);
+                    router.events
+                        .pipe(filter((e) => e instanceof NavigationEnd || e instanceof NavigationCancel ||
+                        e instanceof NavigationError), map(e => {
+                        if (e instanceof NavigationEnd) {
+                            // Navigation assumed to succeed if we get `ActivationStart`
+                            return true;
+                        }
+                        const redirecting = e instanceof NavigationCancel ?
+                            (e.code === 0 /* NavigationCancellationCode.Redirect */ ||
+                                e.code === 1 /* NavigationCancellationCode.SupersededByNewNavigation */) :
+                            false;
+                        return redirecting ? null : false;
+                    }), filter((result) => result !== null), take(1))
+                        .subscribe(() => {
+                        action();
+                    });
+                }
+                return () => {
+                    return locationInitialized.then(() => {
+                        return new Promise(resolve => {
+                            const router = injector.get(Router);
+                            const bootstrapDone = injector.get(BOOTSTRAP_DONE);
+                            afterNextNavigation(() => {
+                                // Unblock APP_INITIALIZER in case the initial navigation was canceled or errored
+                                // without a redirect.
+                                resolve(true);
+                                initNavigation = true;
+                            });
+                            router.afterPreactivation = () => {
+                                // Unblock APP_INITIALIZER once we get to `afterPreactivation`. At this point, we
+                                // assume activation will complete successfully (even though this is not
+                                // guaranteed).
+                                resolve(true);
+                                // only the initial navigation should be delayed until bootstrapping is done.
+                                if (!initNavigation) {
+                                    return bootstrapDone.closed ? of(void 0) : bootstrapDone;
+                                    // subsequent navigations should not be delayed
+                                }
+                                else {
+                                    return of(void 0);
+                                }
+                            };
+                            router.initialNavigation();
+                        });
+                    });
+                };
+            }
+        },
+    ];
+    return routerFeature(2 /* RouterFeatureKind.EnabledBlockingInitialNavigationFeature */, providers);
+}
+/**
+ * Disables initial navigation.
+ *
+ * Use if there is a reason to have more control over when the router starts its initial navigation
+ * due to some complex initialization logic.
+ *
+ * @usageNotes
+ *
+ * Basic example of how you can disable initial navigation:
+ * ```
+ * const appRoutes: Routes = [];
+ * bootstrapApplication(AppComponent,
+ *   {
+ *     providers: [
+ *       provideRouter(appRoutes, withDisabledInitialNavigation())
+ *     ]
+ *   }
+ * );
+ * ```
+ *
+ * @see `provideRouter`
+ *
+ * @returns A set of providers for use with `provideRouter`.
+ *
+ * @publicApi
+ * @developerPreview
+ */
+export function withDisabledInitialNavigation() {
+    const providers = [
+        {
+            provide: APP_INITIALIZER,
+            multi: true,
+            useFactory: () => {
+                const router = inject(Router);
+                return () => {
+                    router.setUpLocationChangeListener();
+                };
+            }
+        },
+        { provide: INITIAL_NAVIGATION, useValue: 2 /* InitialNavigation.Disabled */ }
+    ];
+    return routerFeature(3 /* RouterFeatureKind.DisabledInitialNavigationFeature */, providers);
+}
+/**
+ * Enables logging of all internal navigation events to the console.
+ * Extra logging might be useful for debugging purposes to inspect Router event sequence.
+ *
+ * @usageNotes
+ *
+ * Basic example of how you can enable debug tracing:
+ * ```
+ * const appRoutes: Routes = [];
+ * bootstrapApplication(AppComponent,
+ *   {
+ *     providers: [
+ *       provideRouter(appRoutes, withDebugTracing())
+ *     ]
+ *   }
+ * );
+ * ```
+ *
+ * @see `provideRouter`
+ *
+ * @returns A set of providers for use with `provideRouter`.
+ *
+ * @publicApi
+ * @developerPreview
+ */
+export function withDebugTracing() {
+    let providers = [];
+    if (NG_DEV_MODE) {
+        providers = [{
+                provide: ENVIRONMENT_INITIALIZER,
+                multi: true,
+                useFactory: () => {
+                    const router = inject(Router);
+                    return () => router.events.subscribe((e) => {
+                        // tslint:disable:no-console
+                        console.group?.(`Router Event: ${e.constructor.name}`);
+                        console.log(stringifyEvent(e));
+                        console.log(e);
+                        console.groupEnd?.();
+                        // tslint:enable:no-console
+                    });
+                }
+            }];
+    }
+    else {
+        providers = [];
+    }
+    return routerFeature(1 /* RouterFeatureKind.DebugTracingFeature */, providers);
+}
+const ROUTER_PRELOADER = new InjectionToken(NG_DEV_MODE ? 'router preloader' : '');
+/**
+ * Allows to configure a preloading strategy to use. The strategy is configured by providing a
+ * reference to a class that implements a `PreloadingStrategy`.
+ *
+ * @usageNotes
+ *
+ * Basic example of how you can configure preloading:
+ * ```
+ * const appRoutes: Routes = [];
+ * bootstrapApplication(AppComponent,
+ *   {
+ *     providers: [
+ *       provideRouter(appRoutes, withPreloading(PreloadAllModules))
+ *     ]
+ *   }
+ * );
+ * ```
+ *
+ * @see `provideRouter`
+ *
+ * @param preloadingStrategy A reference to a class that implements a `PreloadingStrategy` that
+ *     should be used.
+ * @returns A set of providers for use with `provideRouter`.
+ *
+ * @publicApi
+ * @developerPreview
+ */
+export function withPreloading(preloadingStrategy) {
+    const providers = [
+        { provide: ROUTER_PRELOADER, useExisting: RouterPreloader },
+        { provide: PreloadingStrategy, useExisting: preloadingStrategy },
+    ];
+    return routerFeature(0 /* RouterFeatureKind.PreloadingFeature */, providers);
+}
+/**
+ * Allows to provide extra parameters to configure Router.
+ *
+ * @usageNotes
+ *
+ * Basic example of how you can provide extra configuration options:
+ * ```
+ * const appRoutes: Routes = [];
+ * bootstrapApplication(AppComponent,
+ *   {
+ *     providers: [
+ *       provideRouter(appRoutes, withRouterConfig({
+ *          onSameUrlNavigation: 'reload'
+ *       }))
+ *     ]
+ *   }
+ * );
+ * ```
+ *
+ * @see `provideRouter`
+ *
+ * @param options A set of parameters to configure Router, see `RouterConfigOptions` for
+ *     additional information.
+ * @returns A set of providers for use with `provideRouter`.
+ *
+ * @publicApi
+ * @developerPreview
+ */
+export function withRouterConfig(options) {
+    const providers = [
+        { provide: ROUTER_CONFIGURATION, useValue: options },
+    ];
+    return routerFeature(5 /* RouterFeatureKind.RouterConfigurationFeature */, providers);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provide_router.js","sourceRoot":"","sources":["../../../../../../packages/router/src/provide_router.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 {LOCATION_INITIALIZED, ViewportScroller} from '@angular/common';\nimport {APP_BOOTSTRAP_LISTENER, APP_INITIALIZER, ApplicationRef, ComponentRef, ENVIRONMENT_INITIALIZER, inject, InjectFlags, InjectionToken, Injector, Provider, Type} from '@angular/core';\nimport {of, Subject} from 'rxjs';\nimport {filter, map, take} from 'rxjs/operators';\n\nimport {Event, NavigationCancel, NavigationCancellationCode, NavigationEnd, NavigationError, stringifyEvent} from './events';\nimport {Routes} from './models';\nimport {Router} from './router';\nimport {InMemoryScrollingOptions, ROUTER_CONFIGURATION, RouterConfigOptions} from './router_config';\nimport {ROUTES} from './router_config_loader';\nimport {PreloadingStrategy, RouterPreloader} from './router_preloader';\nimport {ROUTER_SCROLLER, RouterScroller} from './router_scroller';\nimport {ActivatedRoute} from './router_state';\n\nconst NG_DEV_MODE = typeof ngDevMode === 'undefined' || ngDevMode;\n\n/**\n * Sets up providers necessary to enable `Router` functionality for the application.\n * Allows to configure a set of routes as well as extra features that should be enabled.\n *\n * @usageNotes\n *\n * Basic example of how you can add a Router to your application:\n * ```\n * const appRoutes: Routes = [];\n * bootstrapApplication(AppComponent, {\n *   providers: [provideRouter(appRoutes)]\n * });\n * ```\n *\n * You can also enable optional features in the Router by adding functions from the `RouterFeatures`\n * type:\n * ```\n * const appRoutes: Routes = [];\n * bootstrapApplication(AppComponent,\n *   {\n *     providers: [\n *       provideRouter(appRoutes,\n *         withDebugTracing(),\n *         withRouterConfig({paramsInheritanceStrategy: 'always'}))\n *     ]\n *   }\n * );\n * ```\n *\n * @see `RouterFeatures`\n *\n * @publicApi\n * @developerPreview\n * @param routes A set of `Route`s to use for the application routing table.\n * @param features Optional features to configure additional router behaviors.\n * @returns A set of providers to setup a Router.\n */\nexport function provideRouter(routes: Routes, ...features: RouterFeatures[]): Provider[] {\n  return [\n    provideRoutes(routes), {provide: ActivatedRoute, useFactory: rootRoute, deps: [Router]},\n    {provide: APP_BOOTSTRAP_LISTENER, multi: true, useFactory: getBootstrapListener},\n    features.map(feature => feature.ɵproviders),\n    // TODO: All options used by the `assignExtraOptionsToRouter` factory need to be reviewed for\n    // how we want them to be configured. This API doesn't currently have a way to configure them\n    // and we should decide what the _best_ way to do that is rather than just sticking with the\n    // status quo of how it's done today.\n  ];\n}\n\nexport function rootRoute(router: Router): ActivatedRoute {\n  return router.routerState.root;\n}\n\n/**\n * Helper type to represent a Router feature.\n *\n * @publicApi\n * @developerPreview\n */\nexport interface RouterFeature<FeatureKind extends RouterFeatureKind> {\n  ɵkind: FeatureKind;\n  ɵproviders: Provider[];\n}\n\n/**\n * Helper function to create an object that represents a Router feature.\n */\nfunction routerFeature<FeatureKind extends RouterFeatureKind>(\n    kind: FeatureKind, providers: Provider[]): RouterFeature<FeatureKind> {\n  return {ɵkind: kind, ɵproviders: providers};\n}\n\n/**\n * Registers a [DI provider](guide/glossary#provider) for a set of routes.\n * @param routes The route configuration to provide.\n *\n * @usageNotes\n *\n * ```\n * @NgModule({\n *   providers: [provideRoutes(ROUTES)]\n * })\n * class LazyLoadedChildModule {}\n * ```\n *\n * @publicApi\n */\nexport function provideRoutes(routes: Routes): Provider[] {\n  return [\n    {provide: ROUTES, multi: true, useValue: routes},\n  ];\n}\n\n/**\n * A type alias for providers returned by `withInMemoryScrolling` for use with `provideRouter`.\n *\n * @see `withInMemoryScrolling`\n * @see `provideRouter`\n *\n * @publicApi\n * @developerPreview\n */\nexport type InMemoryScrollingFeature = RouterFeature<RouterFeatureKind.InMemoryScrollingFeature>;\n\n/**\n * Enables customizable scrolling behavior for router navigations.\n *\n * @usageNotes\n *\n * Basic example of how you can enable scrolling feature:\n * ```\n * const appRoutes: Routes = [];\n * bootstrapApplication(AppComponent,\n *   {\n *     providers: [\n *       provideRouter(appRoutes, withInMemoryScrolling())\n *     ]\n *   }\n * );\n * ```\n *\n * @see `provideRouter`\n * @see `ViewportScroller`\n *\n * @publicApi\n * @developerPreview\n * @param options Set of configuration parameters to customize scrolling behavior, see\n *     `InMemoryScrollingOptions` for additional information.\n * @returns A set of providers for use with `provideRouter`.\n */\nexport function withInMemoryScrolling(options: InMemoryScrollingOptions = {}):\n    InMemoryScrollingFeature {\n  const providers = [{\n    provide: ROUTER_SCROLLER,\n    useFactory: () => {\n      const router = inject(Router);\n      const viewportScroller = inject(ViewportScroller);\n      return new RouterScroller(router, viewportScroller, options);\n    },\n  }];\n  return routerFeature(RouterFeatureKind.InMemoryScrollingFeature, providers);\n}\n\nexport function getBootstrapListener() {\n  const injector = inject(Injector);\n  return (bootstrappedComponentRef: ComponentRef<unknown>) => {\n    const ref = injector.get(ApplicationRef);\n\n    if (bootstrappedComponentRef !== ref.components[0]) {\n      return;\n    }\n\n    const router = injector.get(Router);\n    const bootstrapDone = injector.get(BOOTSTRAP_DONE);\n\n    if (injector.get(INITIAL_NAVIGATION) === InitialNavigation.EnabledNonBlocking) {\n      router.initialNavigation();\n    }\n\n    injector.get(ROUTER_PRELOADER, null, InjectFlags.Optional)?.setUpPreloading();\n    injector.get(ROUTER_SCROLLER, null, InjectFlags.Optional)?.init();\n    router.resetRootComponentType(ref.componentTypes[0]);\n    bootstrapDone.next();\n    bootstrapDone.complete();\n  };\n}\n\n/**\n * A subject used to indicate that the bootstrapping phase is done. When initial navigation is\n * `enabledBlocking`, the first navigation waits until bootstrapping is finished before continuing\n * to the activation phase.\n */\nconst BOOTSTRAP_DONE =\n    new InjectionToken<Subject<void>>(NG_DEV_MODE ? 'bootstrap done indicator' : '', {\n      factory: () => {\n        return new Subject<void>();\n      }\n    });\n\n/**\n * This and the INITIAL_NAVIGATION token are used internally only. The public API side of this is\n * configured through the `ExtraOptions`.\n *\n * When set to `EnabledBlocking`, the initial navigation starts before the root\n * component is created. The bootstrap is blocked until the initial navigation is complete. This\n * value is required for [server-side rendering](guide/universal) to work.\n *\n * When set to `EnabledNonBlocking`, the initial navigation starts after the root component has been\n * created. The bootstrap is not blocked on the completion of the initial navigation.\n *\n * When set to `Disabled`, the initial navigation is not performed. The location listener is set up\n * before the root component gets created. Use if there is a reason to have more control over when\n * the router starts its initial navigation due to some complex initialization logic.\n *\n * @see `ExtraOptions`\n */\nconst enum InitialNavigation {\n  EnabledBlocking,\n  EnabledNonBlocking,\n  Disabled,\n}\n\nconst INITIAL_NAVIGATION = new InjectionToken<InitialNavigation>(\n    NG_DEV_MODE ? 'initial navigation' : '',\n    {providedIn: 'root', factory: () => InitialNavigation.EnabledNonBlocking});\n\n/**\n * A type alias for providers returned by `withEnabledBlockingInitialNavigation` for use with\n * `provideRouter`.\n *\n * @see `withEnabledBlockingInitialNavigation`\n * @see `provideRouter`\n *\n * @publicApi\n * @developerPreview\n */\nexport type EnabledBlockingInitialNavigationFeature =\n    RouterFeature<RouterFeatureKind.EnabledBlockingInitialNavigationFeature>;\n\n/**\n * A type alias for providers returned by `withEnabledBlockingInitialNavigation` or\n * `withDisabledInitialNavigation` functions for use with `provideRouter`.\n *\n * @see `withEnabledBlockingInitialNavigation`\n * @see `withDisabledInitialNavigation`\n * @see `provideRouter`\n *\n * @publicApi\n * @developerPreview\n */\nexport type InitialNavigationFeature =\n    EnabledBlockingInitialNavigationFeature|DisabledInitialNavigationFeature;\n\n/**\n * Configures initial navigation to start before the root component is created.\n *\n * The bootstrap is blocked until the initial navigation is complete. This value is required for\n * [server-side rendering](guide/universal) to work.\n *\n * @usageNotes\n *\n * Basic example of how you can enable this navigation behavior:\n * ```\n * const appRoutes: Routes = [];\n * bootstrapApplication(AppComponent,\n *   {\n *     providers: [\n *       provideRouter(appRoutes, withEnabledBlockingInitialNavigation())\n *     ]\n *   }\n * );\n * ```\n *\n * @see `provideRouter`\n *\n * @publicApi\n * @developerPreview\n * @returns A set of providers for use with `provideRouter`.\n */\nexport function withEnabledBlockingInitialNavigation(): EnabledBlockingInitialNavigationFeature {\n  const providers = [\n    {provide: INITIAL_NAVIGATION, useValue: InitialNavigation.EnabledBlocking},\n    {\n      provide: APP_INITIALIZER,\n      multi: true,\n      deps: [Injector],\n      useFactory: (injector: Injector) => {\n        const locationInitialized: Promise<any> =\n            injector.get(LOCATION_INITIALIZED, Promise.resolve());\n        let initNavigation = false;\n\n        /**\n         * Performs the given action once the router finishes its next/current navigation.\n         *\n         * If the navigation is canceled or errors without a redirect, the navigation is considered\n         * complete. If the `NavigationEnd` event emits, the navigation is also considered complete.\n         */\n        function afterNextNavigation(action: () => void) {\n          const router = injector.get(Router);\n          router.events\n              .pipe(\n                  filter(\n                      (e): e is NavigationEnd|NavigationCancel|NavigationError =>\n                          e instanceof NavigationEnd || e instanceof NavigationCancel ||\n                          e instanceof NavigationError),\n                  map(e => {\n                    if (e instanceof NavigationEnd) {\n                      // Navigation assumed to succeed if we get `ActivationStart`\n                      return true;\n                    }\n                    const redirecting = e instanceof NavigationCancel ?\n                        (e.code === NavigationCancellationCode.Redirect ||\n                         e.code === NavigationCancellationCode.SupersededByNewNavigation) :\n                        false;\n                    return redirecting ? null : false;\n                  }),\n                  filter((result): result is boolean => result !== null),\n                  take(1),\n                  )\n              .subscribe(() => {\n                action();\n              });\n        }\n\n        return () => {\n          return locationInitialized.then(() => {\n            return new Promise(resolve => {\n              const router = injector.get(Router);\n              const bootstrapDone = injector.get(BOOTSTRAP_DONE);\n              afterNextNavigation(() => {\n                // Unblock APP_INITIALIZER in case the initial navigation was canceled or errored\n                // without a redirect.\n                resolve(true);\n                initNavigation = true;\n              });\n\n              router.afterPreactivation = () => {\n                // Unblock APP_INITIALIZER once we get to `afterPreactivation`. At this point, we\n                // assume activation will complete successfully (even though this is not\n                // guaranteed).\n                resolve(true);\n                // only the initial navigation should be delayed until bootstrapping is done.\n                if (!initNavigation) {\n                  return bootstrapDone.closed ? of(void 0) : bootstrapDone;\n                  // subsequent navigations should not be delayed\n                } else {\n                  return of(void 0);\n                }\n              };\n              router.initialNavigation();\n            });\n          });\n        };\n      }\n    },\n  ];\n  return routerFeature(RouterFeatureKind.EnabledBlockingInitialNavigationFeature, providers);\n}\n\n/**\n * A type alias for providers returned by `withDisabledInitialNavigation` for use with\n * `provideRouter`.\n *\n * @see `withDisabledInitialNavigation`\n * @see `provideRouter`\n *\n * @publicApi\n * @developerPreview\n */\nexport type DisabledInitialNavigationFeature =\n    RouterFeature<RouterFeatureKind.DisabledInitialNavigationFeature>;\n\n/**\n * Disables initial navigation.\n *\n * Use if there is a reason to have more control over when the router starts its initial navigation\n * due to some complex initialization logic.\n *\n * @usageNotes\n *\n * Basic example of how you can disable initial navigation:\n * ```\n * const appRoutes: Routes = [];\n * bootstrapApplication(AppComponent,\n *   {\n *     providers: [\n *       provideRouter(appRoutes, withDisabledInitialNavigation())\n *     ]\n *   }\n * );\n * ```\n *\n * @see `provideRouter`\n *\n * @returns A set of providers for use with `provideRouter`.\n *\n * @publicApi\n * @developerPreview\n */\nexport function withDisabledInitialNavigation(): DisabledInitialNavigationFeature {\n  const providers = [\n    {\n      provide: APP_INITIALIZER,\n      multi: true,\n      useFactory: () => {\n        const router = inject(Router);\n        return () => {\n          router.setUpLocationChangeListener();\n        };\n      }\n    },\n    {provide: INITIAL_NAVIGATION, useValue: InitialNavigation.Disabled}\n  ];\n  return routerFeature(RouterFeatureKind.DisabledInitialNavigationFeature, providers);\n}\n\n/**\n * A type alias for providers returned by `withDebugTracing` for use with `provideRouter`.\n *\n * @see `withDebugTracing`\n * @see `provideRouter`\n *\n * @publicApi\n * @developerPreview\n */\nexport type DebugTracingFeature = RouterFeature<RouterFeatureKind.DebugTracingFeature>;\n\n/**\n * Enables logging of all internal navigation events to the console.\n * Extra logging might be useful for debugging purposes to inspect Router event sequence.\n *\n * @usageNotes\n *\n * Basic example of how you can enable debug tracing:\n * ```\n * const appRoutes: Routes = [];\n * bootstrapApplication(AppComponent,\n *   {\n *     providers: [\n *       provideRouter(appRoutes, withDebugTracing())\n *     ]\n *   }\n * );\n * ```\n *\n * @see `provideRouter`\n *\n * @returns A set of providers for use with `provideRouter`.\n *\n * @publicApi\n * @developerPreview\n */\nexport function withDebugTracing(): DebugTracingFeature {\n  let providers: Provider[] = [];\n  if (NG_DEV_MODE) {\n    providers = [{\n      provide: ENVIRONMENT_INITIALIZER,\n      multi: true,\n      useFactory: () => {\n        const router = inject(Router);\n        return () => router.events.subscribe((e: Event) => {\n          // tslint:disable:no-console\n          console.group?.(`Router Event: ${(<any>e.constructor).name}`);\n          console.log(stringifyEvent(e));\n          console.log(e);\n          console.groupEnd?.();\n          // tslint:enable:no-console\n        });\n      }\n    }];\n  } else {\n    providers = [];\n  }\n  return routerFeature(RouterFeatureKind.DebugTracingFeature, providers);\n}\n\nconst ROUTER_PRELOADER = new InjectionToken<RouterPreloader>(NG_DEV_MODE ? 'router preloader' : '');\n\n/**\n * A type alias that represents a feature which enables preloading in Router.\n * The type is used to describe the return value of the `withPreloading` function.\n *\n * @see `withPreloading`\n * @see `provideRouter`\n *\n * @publicApi\n * @developerPreview\n */\nexport type PreloadingFeature = RouterFeature<RouterFeatureKind.PreloadingFeature>;\n\n/**\n * Allows to configure a preloading strategy to use. The strategy is configured by providing a\n * reference to a class that implements a `PreloadingStrategy`.\n *\n * @usageNotes\n *\n * Basic example of how you can configure preloading:\n * ```\n * const appRoutes: Routes = [];\n * bootstrapApplication(AppComponent,\n *   {\n *     providers: [\n *       provideRouter(appRoutes, withPreloading(PreloadAllModules))\n *     ]\n *   }\n * );\n * ```\n *\n * @see `provideRouter`\n *\n * @param preloadingStrategy A reference to a class that implements a `PreloadingStrategy` that\n *     should be used.\n * @returns A set of providers for use with `provideRouter`.\n *\n * @publicApi\n * @developerPreview\n */\nexport function withPreloading(preloadingStrategy: Type<PreloadingStrategy>): PreloadingFeature {\n  const providers = [\n    {provide: ROUTER_PRELOADER, useExisting: RouterPreloader},\n    {provide: PreloadingStrategy, useExisting: preloadingStrategy},\n  ];\n  return routerFeature(RouterFeatureKind.PreloadingFeature, providers);\n}\n\n/**\n * A type alias for providers returned by `withRouterConfig` for use with `provideRouter`.\n *\n * @see `withRouterConfig`\n * @see `provideRouter`\n *\n * @publicApi\n * @developerPreview\n */\nexport type RouterConfigurationFeature =\n    RouterFeature<RouterFeatureKind.RouterConfigurationFeature>;\n\n/**\n * Allows to provide extra parameters to configure Router.\n *\n * @usageNotes\n *\n * Basic example of how you can provide extra configuration options:\n * ```\n * const appRoutes: Routes = [];\n * bootstrapApplication(AppComponent,\n *   {\n *     providers: [\n *       provideRouter(appRoutes, withRouterConfig({\n *          onSameUrlNavigation: 'reload'\n *       }))\n *     ]\n *   }\n * );\n * ```\n *\n * @see `provideRouter`\n *\n * @param options A set of parameters to configure Router, see `RouterConfigOptions` for\n *     additional information.\n * @returns A set of providers for use with `provideRouter`.\n *\n * @publicApi\n * @developerPreview\n */\nexport function withRouterConfig(options: RouterConfigOptions): RouterConfigurationFeature {\n  const providers = [\n    {provide: ROUTER_CONFIGURATION, useValue: options},\n  ];\n  return routerFeature(RouterFeatureKind.RouterConfigurationFeature, providers);\n}\n\n/**\n * A type alias that represents all Router features available for use with `provideRouter`.\n * Features can be enabled by adding special functions to the `provideRouter` call.\n * See documentation for each symbol to find corresponding function name. See also `provideRouter`\n * documentation on how to use those functions.\n *\n * @see `provideRouter`\n *\n * @publicApi\n * @developerPreview\n */\nexport type RouterFeatures = PreloadingFeature|DebugTracingFeature|InitialNavigationFeature|\n    InMemoryScrollingFeature|RouterConfigurationFeature;\n\n/**\n * The list of features as an enum to uniquely type each feature.\n */\nexport const enum RouterFeatureKind {\n  PreloadingFeature,\n  DebugTracingFeature,\n  EnabledBlockingInitialNavigationFeature,\n  DisabledInitialNavigationFeature,\n  InMemoryScrollingFeature,\n  RouterConfigurationFeature\n}\n"]}