• Home
• org.mvnpm.at.angular
• router
• 18.2.7
• source code
• router_config_loader.mjs

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

package.esm2022.src.router_config_loader.mjs Maven / Gradle / Ivy

/**
 * @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.dev/license
 */
import { Compiler, inject, Injectable, InjectionToken, NgModuleFactory, } from '@angular/core';
import { ConnectableObservable, from, of, Subject } from 'rxjs';
import { finalize, map, mergeMap, refCount, tap } from 'rxjs/operators';
import { wrapIntoObservable } from './utils/collection';
import { assertStandalone, validateConfig } from './utils/config';
import { standardizeConfig } from './components/empty_outlet';
import * as i0 from "@angular/core";
/**
 * The DI token for a router configuration.
 *
 * `ROUTES` is a low level API for router configuration via dependency injection.
 *
 * We recommend that in almost all cases to use higher level APIs such as `RouterModule.forRoot()`,
 * `provideRouter`, or `Router.resetConfig()`.
 *
 * @publicApi
 */
export const ROUTES = new InjectionToken(ngDevMode ? 'ROUTES' : '');
export class RouterConfigLoader {
    constructor() {
        this.componentLoaders = new WeakMap();
        this.childrenLoaders = new WeakMap();
        this.compiler = inject(Compiler);
    }
    loadComponent(route) {
        if (this.componentLoaders.get(route)) {
            return this.componentLoaders.get(route);
        }
        else if (route._loadedComponent) {
            return of(route._loadedComponent);
        }
        if (this.onLoadStartListener) {
            this.onLoadStartListener(route);
        }
        const loadRunner = wrapIntoObservable(route.loadComponent()).pipe(map(maybeUnwrapDefaultExport), tap((component) => {
            if (this.onLoadEndListener) {
                this.onLoadEndListener(route);
            }
            (typeof ngDevMode === 'undefined' || ngDevMode) &&
                assertStandalone(route.path ?? '', component);
            route._loadedComponent = component;
        }), finalize(() => {
            this.componentLoaders.delete(route);
        }));
        // Use custom ConnectableObservable as share in runners pipe increasing the bundle size too much
        const loader = new ConnectableObservable(loadRunner, () => new Subject()).pipe(refCount());
        this.componentLoaders.set(route, loader);
        return loader;
    }
    loadChildren(parentInjector, route) {
        if (this.childrenLoaders.get(route)) {
            return this.childrenLoaders.get(route);
        }
        else if (route._loadedRoutes) {
            return of({ routes: route._loadedRoutes, injector: route._loadedInjector });
        }
        if (this.onLoadStartListener) {
            this.onLoadStartListener(route);
        }
        const moduleFactoryOrRoutes$ = loadChildren(route, this.compiler, parentInjector, this.onLoadEndListener);
        const loadRunner = moduleFactoryOrRoutes$.pipe(finalize(() => {
            this.childrenLoaders.delete(route);
        }));
        // Use custom ConnectableObservable as share in runners pipe increasing the bundle size too much
        const loader = new ConnectableObservable(loadRunner, () => new Subject()).pipe(refCount());
        this.childrenLoaders.set(route, loader);
        return loader;
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: RouterConfigLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: RouterConfigLoader, providedIn: 'root' }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: RouterConfigLoader, decorators: [{
            type: Injectable,
            args: [{ providedIn: 'root' }]
        }] });
/**
 * Executes a `route.loadChildren` callback and converts the result to an array of child routes and
 * an injector if that callback returned a module.
 *
 * This function is used for the route discovery during prerendering
 * in @angular-devkit/build-angular. If there are any updates to the contract here, it will require
 * an update to the extractor.
 */
export function loadChildren(route, compiler, parentInjector, onLoadEndListener) {
    return wrapIntoObservable(route.loadChildren()).pipe(map(maybeUnwrapDefaultExport), mergeMap((t) => {
        if (t instanceof NgModuleFactory || Array.isArray(t)) {
            return of(t);
        }
        else {
            return from(compiler.compileModuleAsync(t));
        }
    }), map((factoryOrRoutes) => {
        if (onLoadEndListener) {
            onLoadEndListener(route);
        }
        // This injector comes from the `NgModuleRef` when lazy loading an `NgModule`. There is
        // no injector associated with lazy loading a `Route` array.
        let injector;
        let rawRoutes;
        let requireStandaloneComponents = false;
        if (Array.isArray(factoryOrRoutes)) {
            rawRoutes = factoryOrRoutes;
            requireStandaloneComponents = true;
        }
        else {
            injector = factoryOrRoutes.create(parentInjector).injector;
            // When loading a module that doesn't provide `RouterModule.forChild()` preloader
            // will get stuck in an infinite loop. The child module's Injector will look to
            // its parent `Injector` when it doesn't find any ROUTES so it will return routes
            // for it's parent module instead.
            rawRoutes = injector.get(ROUTES, [], { optional: true, self: true }).flat();
        }
        const routes = rawRoutes.map(standardizeConfig);
        (typeof ngDevMode === 'undefined' || ngDevMode) &&
            validateConfig(routes, route.path, requireStandaloneComponents);
        return { routes, injector };
    }));
}
function isWrappedDefaultExport(value) {
    // We use `in` here with a string key `'default'`, because we expect `DefaultExport` objects to be
    // dynamically imported ES modules with a spec-mandated `default` key. Thus we don't expect that
    // `default` will be a renamed property.
    return value && typeof value === 'object' && 'default' in value;
}
function maybeUnwrapDefaultExport(input) {
    // As per `isWrappedDefaultExport`, the `default` key here is generated by the browser and not
    // subject to property renaming, so we reference it with bracket access.
    return isWrappedDefaultExport(input) ? input['default'] : input;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"router_config_loader.js","sourceRoot":"","sources":["../../../../../../packages/router/src/router_config_loader.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.dev/license\n */\n\nimport {\n  Compiler,\n  EnvironmentInjector,\n  inject,\n  Injectable,\n  InjectionToken,\n  Injector,\n  NgModuleFactory,\n  Type,\n} from '@angular/core';\nimport {ConnectableObservable, from, Observable, of, Subject} from 'rxjs';\nimport {finalize, map, mergeMap, refCount, tap} from 'rxjs/operators';\n\nimport {DefaultExport, LoadedRouterConfig, Route, Routes} from './models';\nimport {wrapIntoObservable} from './utils/collection';\nimport {assertStandalone, validateConfig} from './utils/config';\nimport {standardizeConfig} from './components/empty_outlet';\n\n/**\n * The DI token for a router configuration.\n *\n * `ROUTES` is a low level API for router configuration via dependency injection.\n *\n * We recommend that in almost all cases to use higher level APIs such as `RouterModule.forRoot()`,\n * `provideRouter`, or `Router.resetConfig()`.\n *\n * @publicApi\n */\nexport const ROUTES = new InjectionToken<Route[][]>(ngDevMode ? 'ROUTES' : '');\n\ntype ComponentLoader = Observable<Type<unknown>>;\n\n@Injectable({providedIn: 'root'})\nexport class RouterConfigLoader {\n  private componentLoaders = new WeakMap<Route, ComponentLoader>();\n  private childrenLoaders = new WeakMap<Route, Observable<LoadedRouterConfig>>();\n  onLoadStartListener?: (r: Route) => void;\n  onLoadEndListener?: (r: Route) => void;\n  private readonly compiler = inject(Compiler);\n\n  loadComponent(route: Route): Observable<Type<unknown>> {\n    if (this.componentLoaders.get(route)) {\n      return this.componentLoaders.get(route)!;\n    } else if (route._loadedComponent) {\n      return of(route._loadedComponent);\n    }\n\n    if (this.onLoadStartListener) {\n      this.onLoadStartListener(route);\n    }\n    const loadRunner = wrapIntoObservable(route.loadComponent!()).pipe(\n      map(maybeUnwrapDefaultExport),\n      tap((component) => {\n        if (this.onLoadEndListener) {\n          this.onLoadEndListener(route);\n        }\n        (typeof ngDevMode === 'undefined' || ngDevMode) &&\n          assertStandalone(route.path ?? '', component);\n        route._loadedComponent = component;\n      }),\n      finalize(() => {\n        this.componentLoaders.delete(route);\n      }),\n    );\n    // Use custom ConnectableObservable as share in runners pipe increasing the bundle size too much\n    const loader = new ConnectableObservable(loadRunner, () => new Subject<Type<unknown>>()).pipe(\n      refCount(),\n    );\n    this.componentLoaders.set(route, loader);\n    return loader;\n  }\n\n  loadChildren(parentInjector: Injector, route: Route): Observable<LoadedRouterConfig> {\n    if (this.childrenLoaders.get(route)) {\n      return this.childrenLoaders.get(route)!;\n    } else if (route._loadedRoutes) {\n      return of({routes: route._loadedRoutes, injector: route._loadedInjector});\n    }\n\n    if (this.onLoadStartListener) {\n      this.onLoadStartListener(route);\n    }\n    const moduleFactoryOrRoutes$ = loadChildren(\n      route,\n      this.compiler,\n      parentInjector,\n      this.onLoadEndListener,\n    );\n    const loadRunner = moduleFactoryOrRoutes$.pipe(\n      finalize(() => {\n        this.childrenLoaders.delete(route);\n      }),\n    );\n    // Use custom ConnectableObservable as share in runners pipe increasing the bundle size too much\n    const loader = new ConnectableObservable(\n      loadRunner,\n      () => new Subject<LoadedRouterConfig>(),\n    ).pipe(refCount());\n    this.childrenLoaders.set(route, loader);\n    return loader;\n  }\n}\n\n/**\n * Executes a `route.loadChildren` callback and converts the result to an array of child routes and\n * an injector if that callback returned a module.\n *\n * This function is used for the route discovery during prerendering\n * in @angular-devkit/build-angular. If there are any updates to the contract here, it will require\n * an update to the extractor.\n */\nexport function loadChildren(\n  route: Route,\n  compiler: Compiler,\n  parentInjector: Injector,\n  onLoadEndListener?: (r: Route) => void,\n): Observable<LoadedRouterConfig> {\n  return wrapIntoObservable(route.loadChildren!()).pipe(\n    map(maybeUnwrapDefaultExport),\n    mergeMap((t) => {\n      if (t instanceof NgModuleFactory || Array.isArray(t)) {\n        return of(t);\n      } else {\n        return from(compiler.compileModuleAsync(t));\n      }\n    }),\n    map((factoryOrRoutes: NgModuleFactory<any> | Routes) => {\n      if (onLoadEndListener) {\n        onLoadEndListener(route);\n      }\n      // This injector comes from the `NgModuleRef` when lazy loading an `NgModule`. There is\n      // no injector associated with lazy loading a `Route` array.\n      let injector: EnvironmentInjector | undefined;\n      let rawRoutes: Route[];\n      let requireStandaloneComponents = false;\n      if (Array.isArray(factoryOrRoutes)) {\n        rawRoutes = factoryOrRoutes;\n        requireStandaloneComponents = true;\n      } else {\n        injector = factoryOrRoutes.create(parentInjector).injector;\n        // When loading a module that doesn't provide `RouterModule.forChild()` preloader\n        // will get stuck in an infinite loop. The child module's Injector will look to\n        // its parent `Injector` when it doesn't find any ROUTES so it will return routes\n        // for it's parent module instead.\n        rawRoutes = injector.get(ROUTES, [], {optional: true, self: true}).flat();\n      }\n      const routes = rawRoutes.map(standardizeConfig);\n      (typeof ngDevMode === 'undefined' || ngDevMode) &&\n        validateConfig(routes, route.path, requireStandaloneComponents);\n      return {routes, injector};\n    }),\n  );\n}\n\nfunction isWrappedDefaultExport<T>(value: T | DefaultExport<T>): value is DefaultExport<T> {\n  // We use `in` here with a string key `'default'`, because we expect `DefaultExport` objects to be\n  // dynamically imported ES modules with a spec-mandated `default` key. Thus we don't expect that\n  // `default` will be a renamed property.\n  return value && typeof value === 'object' && 'default' in value;\n}\n\nfunction maybeUnwrapDefaultExport<T>(input: T | DefaultExport<T>): T {\n  // As per `isWrappedDefaultExport`, the `default` key here is generated by the browser and not\n  // subject to property renaming, so we reference it with bracket access.\n  return isWrappedDefaultExport(input) ? input['default'] : input;\n}\n"]}