I'm trying to implement lazy routing into my app.

I have a very big project and when it was at router-deprecated I used AsyncRoute, but now it was removed.

So I tried to implement newest lazy loading, but I got an issue
RangeError: Maximum call stack size exceeded
What I'm doing wrong? I did all code like in instructions.

Take a look please

EncountersModule

    import { NgModule } from '@angular/core';

    // import { CommonModule } from '@angular/common';

    /* ---------------  !System modules  --------------- */



    import { SharedModule } from 'sharedModule';   //There is  a lot of shared components/directives/pipes (over 60) and it re-exports CommonModule so I can't avoid it

    /* ---------------  !App outer modules  --------------- */





    import { EncountersComponent } from './encounters.component';

    // import { PassCodeComponent } from '../../shared/components/passcode/passcode.component';





    @NgModule({

      imports: [ SharedModule ],

      declarations: [ EncountersComponent],

      exports: [ EncountersComponent ],

    })





    export class EncountersModule {  }

Here is my app.routing.module

import { NgModule }     from '@angular/core';

// import { ModuleWithProviders }  from '@angular/core';

import { Routes, RouterModule } from '@angular/router';





import { ImagingComponent }      from '../modules/index';

import { DashboardComponent }      from '../modules/index';

import { PrescriptionNoticesComponent }      from '../modules/index';

// import { EncountersComponent } from "../modules/encounters/encounters.component";

import { ScheduleComponent } from "../modules/schedule/schedule.component";

import { AdminComponent } from '../modules/index';









@NgModule({

  imports: [

    RouterModule.forRoot([

      {

        path: '',

        component: DashboardComponent,

        data: { label: 'Dashboard' }

      },

      {

        path: 'encounters',

        // component: EncountersComponent,

        loadChildren: 'production/modules/encounters/encounters.module#EncountersModule',

        data: { label: 'Encounters' }

      },

      {

        path: 'admin',

        component: AdminComponent,

        data: { label: 'Admin' }

      }

    ])

  ],

  exports: [

    RouterModule

  ]

})

export class AppRoutingModule {}









// const appRoutes: Routes = [

//   {

//     path: 'imaging',

//     component: ImagingComponent,

//     data: { label: 'Imaging' }

//   },

//   {

//     path: '',

//     component: DashboardComponent,

//     data: { label: 'Dashboard' }

//   },

//   {

//     path: 'prescription_notices',

//     component: PrescriptionNoticesComponent,

//     data: { label: 'Prescription Notices' }

//   },

//   {

//     path: 'encounters',

//     component: EncountersComponent,

//     data: { label: 'Encounters' }

//   },

//   {

//     path: 'schedule',

//     component: ScheduleComponent,

//     data: { label: 'Schedule' }

//   },

//   {

//     path: 'admin',

//     component: AdminComponent,

//     data: { label: 'Admin' }

//   }

// ];

//

// export const appRoutingProviders: any = [

//

// ];

//

// export const routing: ModuleWithProviders = RouterModule.forRoot(appRoutes);

loadChildren needs to reference module with routing

By assigning a value to loadChildren property inside a route, you have to reference a module, which has a routing system implemented. In other words reference only a module that imports RoutingModule and configures it with forChild(routes) method.

import { NgModule } from '@angular/core';

import { RouterModule, Routes } from '@angular/router';

// import { CommonModule } from '@angular/common';

/* ---------------  !System modules  --------------- */



import { SharedModule } from 'sharedModule';   //There is  a lot of shared components/directives/pipes (over 60) and it re-exports CommonModule so I can't avoid it

/* ---------------  !App outer modules  --------------- */





import { EncountersComponent } from './encounters.component';

// import { PassCodeComponent } from '../../shared/components/passcode/passcode.component';



export const encountersModuleRoutes: Routes = [

  /* configure routes here */

];





@NgModule({

  imports: [ SharedModule, RouterModule.forChild(encountersModuleRoutes) ],

  declarations: [ EncountersComponent],

  exports: [ EncountersComponent ],

})





export class EncountersModule {  }

I am not sure because it is not explicitly mentioned in the documentation (2.4.2), but from the examples in the "Angular Modules" and "Routing & Navigation" guides, I have induced the following pattern:

• The lazy module should have his own routing module.


• The routes array defined in the "lazy-routing.module" should have a single element; the path property of that element should be an empty string; the component property should be defined (necessary when the lazy module provides any service in order to injection works well) and the template of the referenced component should have an element with the <router-outlet> directive. This route usually has a children property.


• The value of the path property of the lazy route defined in the "app-routing.module" ("lazyModulePrefix" in my example) would be the prefix of all the paths defined in the ".lazy-routing.module".

For example:

///////////// app-routing.module.ts /////////////////////

import { NgModule  } from '@angular/core';

import { Routes, RouterModule } from '@angular/router';



import { LoginComponent } from './login/login.component';

import { PageNotFoundComponent } from './page-not-found.component';



const appRoutes: Routes = [

  { path: 'login', component: LoginComponent },

  { path: 'lazyModulePrefix', loadChildren: 'app/lazyModulePath/lazy.module#LazyModule' }, // 

  { path: '', redirectTo: 'login', pathMatch: 'full'},

  { path: '**', component: PageNotFoundComponent },

];



@NgModule({

  imports: [RouterModule.forRoot(appRoutes)],

  exports: [RouterModule]

})

export class AppRoutingModule {}

.

///////////// lazy-routing.module.ts /////////////////////

import { NgModule } from '@angular/core';

import { Routes, RouterModule } from '@angular/router';



import { LazyModuleRootComponent } from './lazy-module-root.component';

import { LazyModuleHomeComponent } from './lazy-module-home.component';

import { AComponentDeclaredInTheLazyModule1 } from './a-component-declared-in-the-lazy-module-1.component';

import { AComponentDeclaredInTheLazyModule2 } from './a-component-declared-in-the-lazy-module-2.component';



const lazyModuleRoutes: Routes = [ // IMPORTANT: this array should contain a single route element with an empty path. And optionally, as many children as desired.

    { path: '',

      component: LazyModuleRootComponent, // the `component` property is necessary when the lazy module provides some service in order to injection work well. If defined, the referenced component's template should have an element with the `<router-outlet>` directive.

      children: [ 

        { path: '', component: LazyModuleHomeComponent }, // this component has no diference with the other children except for the shorter route.

        { path: 'somePath1', component: AComponentDeclaredInTheLazyModule1 },

        { path: 'somePath2', component: AComponentDeclaredInTheLazyModule2 },

    ] } 

];



@NgModule({

    imports: [RouterModule.forChild(lazyModuleRoutes)],

    exports: [RouterModule]

})

export class LazyRoutingModule { }

.

//////////////////// lazy.module.ts ////////////////////

import { NgModule } from '@angular/core';

import { CommonModule } from '@angular/common';



import { SharedModule } from '../shared/shared.module';

import { LazyRoutingModule } from './lazy-routing.module';

import { LazyModuleRootComponent } from './lazy-module-root.component';

import { LazyModuleHomeComponent } from './lazy-module-home.component';

import { AComponentDeclaredInTheLazyModule1 } from './a-component-declared-in-the-lazy-module-1.component';

import { AComponentDeclaredInTheLazyModule2 } from './a-component-declared-in-the-lazy-module-2.component';



@NgModule({

    imports: [

        CommonModule,

        SharedModule,

        LazyRoutingModule,

    ],

    declarations: [

        LazyModuleRootComponent,

        LazyModuleHomeComponent,

        AComponentDeclaredInTheLazyModule1,

        AComponentDeclaredInTheLazyModule2,

    ]

})

export class LazyModule { }

.

//////////////// lazy-module-root.component.ts //////////////////

import { Component } from '@angular/core';



@Component({

    template: '<router-outlet></router-outlet>'

})

export class LazyModueRootComponent { }

With the above code, the routes mapping would be:

http://host/login -> LoginComponent

http://host/lazyModulePrefix -> LazyModuleHomeComponent

http://host/lazyModulePrefix/somePath1 -> AComponentDeclaredInTheLazyModule1

http://host/lazyModulePrefix/somePath2 -> AComponentDeclaredInTheLazyModule2

http://host/anythingElse -> PageNotFoundComponent

Try removing comments. When I updated my router to current in the application I was working on I commented a bunch of stuff out from the old router because I didn't want to lose it. After removing comments some of the strange errors went away.

I was facing same issue and I had everything correct. The following worked for me

1. Stop the angular server


2. Start the server again with ng serve
   

It started working again spontaneously. First make sure you have everything correct as mentioned in other answers and then try this.