{"version":3,"file":"ngx-feature-flag-router.mjs","sources":["../../../../libs/ngx-feature-flag-router/src/lib/utils/utils.ts","../../../../libs/ngx-feature-flag-router/src/lib/angular-utils/default-url-matcher.ts","../../../../libs/ngx-feature-flag-router/src/lib/angular-utils/wrap-into-observable.ts","../../../../libs/ngx-feature-flag-router/src/lib/models/feature-flag-routes.model.ts","../../../../libs/ngx-feature-flag-router/src/lib/preload-strategies/preload-all-non-feature-flag-modules.ts","../../../../libs/ngx-feature-flag-router/src/lib/factories/feature-flag-routes-factory.ts","../../../../libs/ngx-feature-flag-router/src/lib/services/default-feature-flag-routes/default-feature-flag-routes.service.ts","../../../../libs/ngx-feature-flag-router/src/lib/services/feature-flag-routes-factory/feature-flag-routes-factory.service.ts","../../../../libs/ngx-feature-flag-router/src/lib/feature-flag-router.module.ts","../../../../libs/ngx-feature-flag-router/src/ngx-feature-flag-router.ts"],"sourcesContent":["/**\n * source: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat#alternatives\n *\n * Creates a new array with all sub-array elements concatenated into it recursively up to a single depth\n *\n * @param array {T[][]} multi dimensional array of T\n *\n * @returns new array with type T[]\n */\nexport const flattened = <T>(array: T[][]): T[] => ([] as T[]).concat(...array);\n","import { UrlMatchResult, UrlSegment, UrlSegmentGroup } from '@angular/router';\nimport { HasPathProperties } from '../models';\n\n/**\n * `defaultUrlMatcher` from\n * [`angular/packages/router/src/shared.ts`](https://github.com/angular/angular/blob/master/packages/router/src/shared.ts)\n *\n * Since angular doesn't export this function, here is a copy of it using version 13.2.x\n *\n * This is a known request since this can be useful for extended matcher's default behavior:\n * [github](https://github.com/angular/angular/issues/35928)\n *\n * Matches the route configuration (`route`) against the actual URL (`segments`).\n */\nexport function defaultUrlMatcher(segments: UrlSegment[], segmentGroup: UrlSegmentGroup, route: HasPathProperties): UrlMatchResult | null {\n    // This part is changed,\n    // default behavior is to assume that routes always have property `path` as string\n    // to allow for UrlMatcher always run on navigate, path is set to `undefined` instead of empty string\n    // Angular normally avoids using the UrlMatcher if path is empty string\n    const parts = getRoutePath(route).split('/');\n\n    // Extra exit early condition for handling if url is empty\n    if (segments.length === 0 && parts.length === 1 && parts[0] === '') {\n        return { consumed: segments.slice(0, parts.length), posParams: {} };\n    }\n\n    if (parts.length > segments.length) {\n        // The actual URL is shorter than the config, no match\n        return null;\n    }\n\n    if (route.pathMatch === 'full' && (segmentGroup.hasChildren() || parts.length < segments.length)) {\n        // The config is longer than the actual URL but we are looking for a full match, return null\n        return null;\n    }\n\n    const posParams: { [key: string]: UrlSegment } = {};\n\n    // Check each config part against the actual URL\n    for (let index = 0; index < parts.length; index++) {\n        const part = parts[index];\n        const segment = segments[index];\n        const isParameter = part.startsWith(':');\n        if (isParameter) {\n            posParams[part.substring(1)] = segment;\n        } else if (part !== segment.path) {\n            // The actual URL part does not match the config, no match\n            return null;\n        }\n    }\n\n    return { consumed: segments.slice(0, parts.length), posParams };\n}\n\n/**\n * Get path of `Route`. Checks `path` property and `featureFlagPath` property.\n * If no path is found, returns empty string.\n */\nexport const getRoutePath = (route: HasPathProperties): string => {\n    const path = route.path || route.featureFlagPath;\n\n    if (!path) {\n        return '';\n    }\n\n    return path;\n};\n","import { ɵisObservable as isObservable, ɵisPromise as isPromise } from '@angular/core';\nimport { from, Observable, of } from 'rxjs';\n\n/**\n * `wrapIntoObservable` from\n * [angular/packages/router/src/utils/collection.ts](https://github.com/angular/angular/blob/master/packages/router/src/utils/collection.ts)\n *\n * Since angular doesn't export this function, here is a copy of it using version 13.2.x\n *\n * Wrap Promise / Observable / syncronous value with an Observable\n */\nexport function wrapIntoObservable<T>(value: T | Promise<T> | Observable<T>): Observable<T> {\n    if (isObservable(value)) {\n        return value;\n    }\n\n    if (isPromise(value)) {\n        // Use `Promise.resolve()` to wrap promise-like instances.\n        // Required ie when a Resolver returns a AngularJS `$q` promise to correctly trigger the\n        // change detection.\n        return from(Promise.resolve(value));\n    }\n\n    return of(value);\n}\n","import { LoadChildren, Route, Routes } from '@angular/router';\nimport { Observable } from 'rxjs';\n\nexport interface HasPathProperties {\n    path?: string;\n    featureFlagPath?: string;\n    pathMatch?: string;\n}\n\n/**\n * `Route` interface but with added optional never properties\n * to allow checking against `FeatureFlagRoute` properties.\n *\n * Also assumes that children can be FeatureFlagRoutes and not just Routes.\n */\nexport type PatchedRoute = Omit<Route, 'children'> & {\n    featureFlagPath?: never;\n    alternativeLoadChildren?: never;\n    featureFlag?: never;\n    children?: FeatureFlagPatchedRoutes;\n    loadChildren?: LoadChildren;\n};\n\nexport type ProcessedFeatureFlagRoute = Omit<FeatureFlagRoute, 'children' | 'loadChildren' | 'alternativeLoadChildren' | 'featureFlag'> & {\n    children?: ProcessedFeatureFlagRoute[];\n    loadChildren?: LoadChildren | undefined;\n    alternativeLoadChildren?: LoadChildren | undefined;\n    featureFlag?: FeatureFlagRoute['featureFlag'] | undefined;\n} & (\n        | {\n              featureFlagPath?: string | undefined;\n              path: undefined;\n          }\n        | {\n              featureFlagPath?: never;\n              path?: string;\n          }\n    );\n\n/**\n * `FeatureFlagRoute` extends `Route`\n *\n * All properties are the same as `Route` except that `loadChildren` is required instead of optional, and there are extra properties:\n * 1. alternativeLoadChildren\n * 2. featureFlag\n *\n * When using `FeatureFlagRoute` to navigate, `featureFlag` determines\n * if `loadChildren` or `alternativeLoadChildren` is used when lazy loading module for navigation\n *\n * If `featureFlag`'s latest value is `false`, `loadChildren` is used,\n * and if `featureFlag`'s latest value is `true`, `alternativeLoadChildren` is used instead.\n */\nexport interface FeatureFlagRoute extends Route {\n    children?: FeatureFlagRoutes;\n\n    /**\n     * An object specifying lazy-loaded child routes.\n     *\n     * if `alternativeLoadChildren` and `featureFlag` are also defined,\n     * `loadChildren` will be used to lazy-load child routes when `featureFlag`'s latest value is `false`\n     */\n    loadChildren: LoadChildren;\n    /**\n     * An object specifying lazy-loaded child routes.\n     *\n     * if `loadChildren` and `featureFlag` are also defined,\n     * `alternativeLoadChildren` will be used to lazy-load child routes when `featureFlag`'s latest value is `true`\n     */\n    alternativeLoadChildren: LoadChildren;\n    /**\n     * Used to determine if navigation to this route should use `loadChildren` or `alternativeLoadChildren`\n     * to lazy-load child routes.\n     *\n     * If `featureFlag`'s latest value is `false`, `loadChildren` is used,\n     * and if `featureFlag`'s latest value is `true`, `alternativeLoadChildren` is used instead.\n     */\n    featureFlag: () => boolean | Observable<boolean>;\n}\n\n/**\n * Array of `FeatureFlagRoute` or `Route`\n *\n * `FeatureFlagRoute` properties are the same as `Route` except that `loadChildren` is required instead of optional,\n * and there are extra properties:\n * 1. alternativeLoadChildren\n * 2. featureFlag\n *\n * These properties are used to allow for conditionally lazy-loading an alternative `NgModule` than `loadChildren`\n * Outside of these two properties, `FeatureFlagRoute` serve the same purpose and functionality of `Route`\n *\n * A configuration object that defines a single route.\n * A set of routes are collected in a Routes array to define a Router configuration.\n * The router attempts to match segments of a given URL against each route,\n * using the configuration options defined in this object.\n *\n * @see `FeatureFlagRoute`\n * @see `Route`\n * @see `Routes`\n */\nexport type FeatureFlagRoutes = (FeatureFlagRoute | Route)[];\n\n/**\n * Same type as FeatureFlagRoutes, but instead of Route it uses PatchedRoute\n * to allow for easier type checks\n *\n * @see `PatchedRoute``\n */\nexport type FeatureFlagPatchedRoutes = (FeatureFlagRoute | PatchedRoute)[];\n\n/**\n * Service with method `getFeatureRoutes`\n *\n * Used to add addtional `ROUTES` to NgModule importing `FeatureFlagRouterModule`\n *\n * These `ROUTES` can use a Feature Flag to determine which NgModule to lazy load when navigating to a path\n */\nexport abstract class FeatureFlagRoutesService {\n    /**\n     * `getFeatureRoutes` is expected to return an Array of `FeatureFlagRoute` or `Route` (`NotFeatureFlagRoute`)\n     *\n     * These values will be appended to the beginning of the `ROUTES` used by NgModule importing `FeatureFlagRouterModule`\n     *\n     * This means that previous `ROUTES` may be overridden by the `ROUTES` returned by this method\n     */\n    abstract getFeatureRoutes(): FeatureFlagRoutes;\n}\n\nexport abstract class FactoryService {\n    // Fallback to the normal set of `ROUTES`\n    abstract getRoutesFromFeatureFlagRoutes(featureFlagRoutes: FeatureFlagRoutes): Routes;\n\n    // Override normal `ROUTES` that determine which lazy-loaded child routes to use by using  that use `featureFlag`\n    abstract getRoutesFromFeatureFlagRoutesService(): Routes;\n}\n\nexport type FeatureFlagRoutesFactory = (routes: FeatureFlagRoutes) => (featureFlagRoutesFactoryService: FactoryService) => PatchedRoute[];\n","import { Injectable } from '@angular/core';\nimport { PreloadingStrategy, Route } from '@angular/router';\nimport { Observable, of } from 'rxjs';\nimport { catchError } from 'rxjs/operators';\nimport { FeatureFlagRoute } from '../models';\n\n/**\n * Preload all NgModules except any FeatureFlagRoutes.\n *\n * This means that any route that has properties `alternativeLoadChildren` or `featureFlag`\n * will not be loaded using the preloading strategy.\n *\n * This can be useful for avoiding circular lazy-loading.\n */\n@Injectable()\nexport class PreloadAllNonFeatureFlagModules implements PreloadingStrategy {\n    preload(route: Partial<FeatureFlagRoute> & Route, fn: () => Observable<any>): Observable<any> {\n        // Check if possible FeatureFlagRoute has required properties\n        // to involve lazy-loading modules based on FeatureFlag\n        if (route.alternativeLoadChildren && route.featureFlag) {\n            return of(null);\n        }\n\n        // If not, call fn to load Module asap\n        // source: https://github.com/angular/angular/blob/14.0.x/packages/router/src/router_preloader.ts#L43\n        return fn().pipe(catchError(() => of(null)));\n    }\n}\n","import { FactoryService, FeatureFlagRoutes, FeatureFlagRoutesFactory } from '../models';\n\n/**\n * Used to provide `ROUTES` when using `useFactory`\n *\n * Combines routes and `FeatureFlagRoutesFactoryService` routes\n *\n * @param routes {FeatureFlagRoutes} - routes provided as the first argument for `FeatureFlagRouterModule.child()`\n *\n * @returns `FeatureFlagRoutes[]`\n */\nexport const featureFlagRoutesFactory: FeatureFlagRoutesFactory = (routes: FeatureFlagRoutes) => (factoryService: FactoryService) => {\n    return [\n        // Override normal `ROUTES` that determine which lazy-loaded child routes to use by using  that use `featureFlag`\n        ...factoryService.getRoutesFromFeatureFlagRoutesService(),\n\n        // Fallback to the normal set of `ROUTES`\n        ...factoryService.getRoutesFromFeatureFlagRoutes(routes),\n    ];\n};\n","import { FeatureFlagRoutes, FeatureFlagRoutesService } from '../../models';\n\n/**\n * `FeatureFlagRoutesService` used when no `FeatureFlagRoutesService` is provided\n *\n * Returns empty `FeatureFlagRoutes` Array\n */\nexport class DefaultFeatureFlagRoutesService implements FeatureFlagRoutesService {\n    getFeatureRoutes(): FeatureFlagRoutes {\n        return [];\n    }\n}\n","import { Injectable, isDevMode, NgModuleFactory, OnDestroy } from '@angular/core';\nimport { LoadChildren, Route, UrlMatcher, UrlSegment, UrlSegmentGroup } from '@angular/router';\nimport { Observable, Subject } from 'rxjs';\nimport { catchError, map, mergeMap, shareReplay, take, takeUntil, tap } from 'rxjs/operators';\nimport { defaultUrlMatcher, wrapIntoObservable } from '../../angular-utils';\nimport {\n    FactoryService,\n    FeatureFlagPatchedRoutes,\n    FeatureFlagRoute,\n    FeatureFlagRoutesService,\n    LegacyUrlMatcher,\n    LoadChildrenObservableCallback,\n    ModernUrlMatcher,\n    PatchedRoute,\n    ProcessedFeatureFlagRoute,\n} from '../../models';\nimport { flattened } from '../../utils';\n\n@Injectable()\nexport class FeatureFlagRoutesFactoryService implements FactoryService, OnDestroy {\n    private readonly unsubscribe$ = new Subject<void>();\n    constructor(private readonly featureFlagRoutesService: FeatureFlagRoutesService) {}\n\n    getLoadChildrenObservableCallback(loadChildren: LoadChildren): LoadChildrenObservableCallback {\n        return () => {\n            // Typecheck for Angular 9 (which supports the deprecated string type for LoadChildren)\n            if (typeof loadChildren !== 'function') {\n                throw new Error('loadChildren must be a function');\n            }\n\n            const observableOfLoadChildren = wrapIntoObservable(loadChildren());\n\n            return observableOfLoadChildren.pipe(\n                map((loadChildrenValue) => {\n                    if (loadChildrenValue instanceof NgModuleFactory) {\n                        throw new Error('NgModuleFactory is deprecated and is not supported');\n                    }\n\n                    return loadChildrenValue;\n                }),\n            );\n        };\n    }\n\n    getLoadChildrens(\n        featureFlag: Observable<boolean>,\n        loadChildren: LoadChildren,\n        alternativeFeatureChildren: LoadChildren,\n    ): [LoadChildrenObservableCallback, LoadChildrenObservableCallback] {\n        const module: LoadChildrenObservableCallback = this.getLoadChildrenObservableCallback(loadChildren);\n        const alternativeModule: LoadChildrenObservableCallback = this.getLoadChildrenObservableCallback(alternativeFeatureChildren);\n\n        let modules: {\n            first: LoadChildrenObservableCallback;\n            second: LoadChildrenObservableCallback;\n        } | null = null;\n\n        const handleError = () => {\n            if (isDevMode()) {\n                console.error('`alternativeLoadChildren` is unreliable. All routes will use `loadChildren` instead');\n            }\n\n            modules = {\n                first: module,\n                second: module,\n            };\n        };\n\n        const handleFeatureFlagValue = (featureFlagValue: boolean): void => {\n            const expectedFirstModule = featureFlagValue ? alternativeModule : module;\n            const expectedSecondModule = featureFlagValue ? module : alternativeModule;\n\n            if (modules && (modules.first !== expectedFirstModule || modules.second !== expectedSecondModule)) {\n                console.error('Unexpected modules were set out of sync of each other');\n                handleError();\n                return;\n            }\n\n            modules = {\n                first: expectedFirstModule,\n                second: expectedSecondModule,\n            };\n        };\n\n        const firstLoadChildren = () => {\n            if (modules && modules.first) {\n                return modules.first();\n            }\n\n            return featureFlag.pipe(\n                mergeMap((featureFlagValue: boolean) => {\n                    handleFeatureFlagValue(featureFlagValue);\n\n                    return modules!.first();\n                }),\n                catchError((error) => {\n                    console.error(error);\n                    handleError();\n                    return module();\n                }),\n            );\n        };\n\n        const secondLoadChildren = () => {\n            if (modules && modules.second) {\n                return modules.second();\n            }\n\n            return featureFlag.pipe(\n                mergeMap((featureFlagValue: boolean) => {\n                    handleFeatureFlagValue(featureFlagValue);\n\n                    return modules!.second();\n                }),\n                catchError((error) => {\n                    console.error(error);\n                    handleError();\n                    return module();\n                }),\n            );\n        };\n\n        return [() => firstLoadChildren(), () => secondLoadChildren()];\n    }\n\n    getUrlMatchers(featureFlagMatchesInitialValue: () => boolean, possibleUrlMatcher?: UrlMatcher): [UrlMatcher, UrlMatcher] {\n        const urlMatcher: ModernUrlMatcher = possibleUrlMatcher || defaultUrlMatcher;\n\n        const firstUrlMatcher: ModernUrlMatcher = (segments: UrlSegment[], group: UrlSegmentGroup, route: Route) => {\n            // Since current feature flag value matches the initial value found,\n            // it's safe to use the first lazy-load route since it lazy-loads alternative module based on feature flag\n            if (featureFlagMatchesInitialValue()) {\n                return urlMatcher(segments, group, route);\n            }\n\n            // Since current feature flag value doesn't match initial value found,\n            // second lazy-load route should be used since it lazy-loads original module based on feature flag\n            return null;\n        };\n\n        return [firstUrlMatcher, urlMatcher] as [LegacyUrlMatcher, LegacyUrlMatcher];\n    }\n\n    getRoutesFromFeatureFlagRoute(featureFlagRoute: FeatureFlagRoute): [ProcessedFeatureFlagRoute, ProcessedFeatureFlagRoute] {\n        const { featureFlag, loadChildren, alternativeLoadChildren } = featureFlagRoute;\n\n        const featureFlagFunctionReturn = featureFlag();\n\n        // If null, firstLoadChildrenFeatureFlagValue will initalize when initialFeatureFlag$\n        // emits its first value (boolean)\n        let firstLoadChildrenFeatureFlagValue: boolean | null =\n            typeof featureFlagFunctionReturn === 'boolean' ? featureFlagFunctionReturn : null;\n        let observedFeatureFlagValue: boolean | null = firstLoadChildrenFeatureFlagValue;\n\n        const featureFlagMatchesInitialValue = () => {\n            if (firstLoadChildrenFeatureFlagValue == null) {\n                return true;\n            }\n\n            const syncronousFeatureFlagFunctionValue = featureFlag();\n\n            if (typeof syncronousFeatureFlagFunctionValue === 'boolean') {\n                observedFeatureFlagValue = syncronousFeatureFlagFunctionValue;\n            }\n\n            return observedFeatureFlagValue === firstLoadChildrenFeatureFlagValue;\n        };\n\n        const featureFlag$: Observable<boolean> = wrapIntoObservable(featureFlagFunctionReturn);\n\n        // featureFlag returns a boolean syncronously, so there's no reason to\n        // make a subscription since the observed feature flag value won't be used\n        // to determine if first UrlMatcher should fail\n        if (typeof featureFlagFunctionReturn !== 'boolean') {\n            featureFlag$.pipe(takeUntil(this.unsubscribe$)).subscribe((value) => {\n                observedFeatureFlagValue = value;\n            });\n        }\n\n        const initialFeatureFlag$ = featureFlag$.pipe(\n            tap((loadChildFeatureFlagValue) => {\n                if (firstLoadChildrenFeatureFlagValue == null) {\n                    firstLoadChildrenFeatureFlagValue = loadChildFeatureFlagValue;\n                }\n\n                observedFeatureFlagValue = loadChildFeatureFlagValue;\n            }),\n            shareReplay(1),\n            take(1),\n        );\n\n        const [firstLoadChildren, secondLoadChildren] = this.getLoadChildrens(initialFeatureFlag$, loadChildren, alternativeLoadChildren);\n\n        const [firstUrlMatcher, secondUrlMatcher] = this.getUrlMatchers(featureFlagMatchesInitialValue, featureFlagRoute.matcher);\n\n        const children = this.getChildrenFromFeatureFlagRoutes(featureFlagRoute);\n\n        return [\n            {\n                ...featureFlagRoute,\n                // Store path as a different property\n                // This is done to avoid runtime error when Routehas both `path` and `matcher` property\n                // https://github.com/angular/angular/blob/13.3.x/packages/router/src/utils/config.ts#L67\n                featureFlagPath: featureFlagRoute.path,\n                // Note that if we end up using `path` again, we must avoid empty strings\n                // to allow for UrlMatcher always run on navigate, path is set to `undefined` instead of empty string\n                // Angular normally avoids using the UrlMatcher if path is empty string since Angular will cache the first result\n                path: undefined,\n                children,\n                loadChildren: firstLoadChildren,\n                matcher: firstUrlMatcher,\n            },\n            {\n                ...featureFlagRoute,\n                // Store path as a different property\n                // This is done to avoid runtime error when Routehas both path and matcher property\n                // https://github.com/angular/angular/blob/13.3.x/packages/router/src/utils/config.ts#L67\n                featureFlagPath: featureFlagRoute.path,\n                // Note that if we end up using `path` again, we must avoid empty strings\n                // to allow for UrlMatcher always run on navigate, path is set to `undefined` instead of empty string\n                // Angular normally avoids using the UrlMatcher if path is empty string since Angular will cache the first result\n                path: undefined,\n                children,\n                loadChildren: secondLoadChildren,\n                matcher: secondUrlMatcher,\n            },\n        ];\n    }\n\n    getChildrenFromFeatureFlagRoutes(featureFlagRoutes: FeatureFlagRoute | PatchedRoute): ProcessedFeatureFlagRoute[] | undefined {\n        if (!featureFlagRoutes.children) {\n            return undefined;\n        }\n\n        return this.getRoutesFromFeatureFlagRoutes(featureFlagRoutes.children);\n    }\n\n    getRoutesFromFeatureFlagRoutes(featureFlagRoutes: FeatureFlagPatchedRoutes): ProcessedFeatureFlagRoute[] {\n        return flattened(\n            featureFlagRoutes.map((featureFlagRoute) => {\n                if (!featureFlagRoute.alternativeLoadChildren) {\n                    return [\n                        {\n                            ...featureFlagRoute,\n                            children: this.getChildrenFromFeatureFlagRoutes(featureFlagRoute),\n                        },\n                    ];\n                }\n\n                return this.getRoutesFromFeatureFlagRoute(featureFlagRoute);\n            }),\n        );\n    }\n\n    getRoutesFromFeatureFlagRoutesService(): ProcessedFeatureFlagRoute[] {\n        return this.getRoutesFromFeatureFlagRoutes(this.featureFlagRoutesService.getFeatureRoutes());\n    }\n\n    ngOnDestroy(): void {\n        this.unsubscribe$.next();\n        this.unsubscribe$.complete();\n    }\n}\n","import { ANALYZE_FOR_ENTRY_COMPONENTS, forwardRef, ModuleWithProviders, NgModule, Optional, Type } from '@angular/core';\nimport { Router, RouterModule, ROUTES } from '@angular/router';\nimport { featureFlagRoutesFactory } from './factories';\nimport { FactoryService, FeatureFlagRoutes, FeatureFlagRoutesService } from './models';\nimport { FeatureFlagRoutesFactoryService, DefaultFeatureFlagRoutesService } from './services';\n\n/**\n * You should use `FeatureRouterModule` instead of `RouterModule`\n * when you want to conditionally lazy-load `NgModules` based on a feature flag\n *\n * This feature flag can be a function where its return value determines which `loadChildren` function to use for lazy-loading:\n * 1. `() => boolean`\n * 2. `() => Observable<boolean>`\n *\n * You can also inject a Service that extends `FeatureFlagRoutesService` for more complex logic\n * i.e. use `HttpClient`, etc: `FeatureRouterModule.forChild([...], SomeService)`\n *\n * Adds the same directives and providers as `RouterModule` and can be used interchangeably to lazy-loaded bundles for an `NgModule`:\n *\n * `FeatureRouterModule.forChild(...)`\n *\n * Unlike `RouterModule`, `FeatureFlagRouterModule` does not have a forRoot() method.\n *\n * For FeatureFlagRouterModule.forChild() to function properly, you have to call RouterModule.forRoot() in some parent `NgModule`\n * just like you would if you wanted to use RouterModule.forChild()\n *\n * @see `RouterModule`\n */\n@NgModule({\n    exports: [RouterModule],\n    providers: [DefaultFeatureFlagRoutesService],\n})\nexport class FeatureFlagRouterModule {\n    // Angular's `RouterModule` injects Router so it gets created eagerly,\n    // so `FeatureFlagRouterModule` will do so as well\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function\n    constructor(@Optional() router: Router) {}\n\n    /**\n     * Creates a module with all the router directives and a provider registering routes,\n     * without creating a new Router service.\n     * When registering for submodules and lazy-loaded submodules, create the NgModule as follows:\n     *\n     * ```\n     * @NgModule({\n     *   imports: [FeatureFlagRouterModule.forChild(ROUTES)]\n     * })\n     * class MyNgModule {}\n     * ```\n     *\n     * You can also provide a service to unshift additional `Route` objects for more complex situations:\n     * ```\n     * @NgModule({\n     *   imports: [FeatureFlagRouterModule.forChild(ROUTES, MyService)]\n     * })\n     * class MyNgModule {}\n     * ```\n     *\n     * @param routes An array of `FeatureFlagRoutes` objects that define the navigation paths for the submodule.\n     * `FeatureFlagRoutes` objects are `Route` with extra options\n     * @param featureFlagRoutesService (Optional) Service used to generate an array of `FeatureFlagRoutes` objects.\n     * The array generated by `featureFlagRoutesService` will be combined with `routes` argument: `[...serviceRoutes, ...routes]`\n     * @return The new NgModule.\n     *\n     */\n    static forChild(\n        routes: FeatureFlagRoutes,\n        featureFlagRoutesService?: Type<FeatureFlagRoutesService>,\n    ): ModuleWithProviders<FeatureFlagRouterModule> {\n        const serviceType = featureFlagRoutesService || DefaultFeatureFlagRoutesService;\n\n        return {\n            ngModule: FeatureFlagRouterModule,\n            providers: [\n                {\n                    provide: FeatureFlagRoutesService,\n                    useExisting: forwardRef(() => serviceType),\n                },\n                FeatureFlagRoutesFactoryService,\n                {\n                    provide: FactoryService,\n                    useClass: FeatureFlagRoutesFactoryService,\n                },\n                {\n                    provide: ROUTES,\n                    useFactory: featureFlagRoutesFactory(routes),\n                    multi: true,\n                    deps: [FactoryService, FeatureFlagRoutesService],\n                },\n                // Providing `ANALYZE_FOR_ENTRY_COMPONENTS` to match how Angular's `provideRoute` Provider helper works\n                // They also pass `ROUTES` value as `ANALYZE_FOR_ENTRY_COMPONENTS`\n                {\n                    provide: ANALYZE_FOR_ENTRY_COMPONENTS,\n                    multi: true,\n                    useValue: ROUTES,\n                },\n            ],\n        };\n    }\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":["isObservable","isPromise","i1.FeatureFlagRoutesService"],"mappings":"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"}