Как вручную использовать ленивый модуль?

Я пробовал загружать модули без маршрутизатора, используя SystemJsNgModuleLoader, но не смог заставить его работать:

this.loader.load(url).then(console.info);

Я получаю Cannot find module xxx для любой строки, которую я использую для URL (aboslute/relative urls/paths... пробовал много вариантов). Я просмотрел исходный код Router и не смог найти ничего другого, кроме этого SystemJsNgModuleLoader. Я даже не уверен, что должен использовать это...


Этот вопрос был задан только вчера на конференции ng-europe 2016 - Мишко и Матиас ответили:

Мишко Хевери:Нужно просто получить модуль, оттуда вы можете получить компонент factory, и вы можете динамически загружать компонент factory в любом месте приложения. Это именно то, что делает внутренний маршрутизатор. Поэтому для вас это тоже очень важно.

Матиас НимелаЕдинственное, что нужно отметить, это то, что на модуле [Ng] есть что-то под названием entryComponents и которое идентифицирует компоненты, которые могут быть ленивы загружены, - что запись в этот набор компонентов. Поэтому, когда у вас есть модули, которые ленивы загружены, введите материал в entryComponents.

... но это не тот прорыв вперед без примеров и плохих документов по этому вопросу (;

Кто-нибудь знает, как загружать модули вручную, не используя Route.loadChildren? Как заполучить модуль и что такое материал, который должен войти в entryComponents (я читаю FAQ, но не могу попробовать без загрузки модуля )?

Ответ 1

Кто-нибудь знает, как загрузить модули вручную, без использования Route.loadChildren?

Вы можете использовать SystemJsNgModuleLoader для получения фабрики модулей:

this.loader.load('./src/lazy.module#TestModule').then((factory: NgModuleFactory<any>) => {
  console.log(factory);
});

Для угловых 8 см. Ленивый модуль нагрузки в угловых 8

Вот как это может выглядеть:

lazy.module.ts

@Component({
  selector: 'test',
  template: 'I'm lazy module',
})
export class Test {}

@NgModule({
  imports: [CommonModule],
  declarations: [Test],
  entryComponents: [Test]
})
export class LazyModule {
  static entry = Test;
}

app.ts

import {
  Component, NgModule, ViewContainerRef,
  SystemJsNgModuleLoader, NgModuleFactory,
  Injector} from '@angular/core'
import {BrowserModule} from '@angular/platform-browser'

@Component({
  selector: 'my-app',
  template: '<h2>Test lazy loading module</h2>',
})
export class AppComponent {
  constructor(
    private loader: SystemJsNgModuleLoader, 
    private inj: Injector, 
    private vcRef: ViewContainerRef) {}

  ngOnInit() {
     this.loader.load('./src/lazy.module#LazyModule')
       .then((moduleFactory: NgModuleFactory<any>) => {
         const moduleRef = moduleFactory.create(this.inj);
         const entryComponent = (<any>moduleFactory.moduleType).entry;
         const compFactory = 
               moduleRef.componentFactoryResolver.resolveComponentFactory(entryComponent);
         this.vcRef.createComponent(compFactory);
      });
  }
} 

@NgModule({
  imports: [ BrowserModule ],
  declarations: [ AppComponent ],
  providers: [SystemJsNgModuleLoader],
  bootstrap: [ AppComponent ]
})
export class AppModule {} 
this.loader.load('./src/test.module#TestModule').then((factory: NgModuleFactory<any>) => {
  console.log(factory);
});

Пример плунжера

Есть два варианта прекомпиляции модуля для AOT:

1) Варианты угловых CLI lazyModules (начиная с Angular 6)

Используйте встроенную функцию angular/cli:

{
  "projects": {
    "app": {
      "architect": {
        "build": {
          "options": {
            "lazyModules": [  <====== add here all your lazy modules
              "src/path-to.module"
            ]
          }
        }
      }
    }
  }
} 

Увидеть

2) Использование provideRoutes из RouterModule

app.module.ts

providers: [
  SystemJsNgModuleLoader,
  provideRoutes([
     { loadChildren: 'app/lazy/lazy.module#LazyModule' }
  ])
],

app.component.ts

export class AppComponent implements  OnInit {
    title = 'Angular cli Example SystemJsNgModuleLoader.load';

    @ViewChild('container', { read: ViewContainerRef }) container: ViewContainerRef;

    constructor(private loader: SystemJsNgModuleLoader, private inj: Injector) {}

    ngOnInit() {
        this.loader.load('app/lazy/lazy.module#LazyModule').then((moduleFactory: NgModuleFactory<any>) => {
            const entryComponent = (<any>moduleFactory.moduleType).entry;
            const moduleRef = moduleFactory.create(this.inj);

            const compFactory = moduleRef.componentFactoryResolver.resolveComponentFactory(entryComponent);
            this.container.createComponent(compFactory);
        });
    }
}

Github репо угловой-ленивый


Ленивая загрузка с Webpack и AOT

Компиляция с использованием ngc

Инициализация компилятора с использованием следующей фабрики

export function createJitCompiler () {
    return new JitCompilerFactory([{useDebug: false, useJit: true}]).createCompiler();
}

Github репо

Ответ 2

[Угловой 6]

Привет,

Я поделюсь своим решением здесь, потому что я не нашел, как lazyload без маршрутизатора на stackoverflow.

Способ Yurzui работает, но он использует модуль Router для компиляции отложенного модуля, а я не хотел его использовать.

В нашем файле src/angular.json мы можем попросить @angular/cli скомпилировать модуль отдельно.

Для этого мы добавляем ключ lazyModules в "project"> "your-app-name"> "architect"> "build"> "options".

Как это:

  "$schema": "./node_modules/@angular/cli/lib/config/schema.json",
  "version": 1,
  "newProjectRoot": "projects", 
  "projects": {
    "lazy-load-app": {
      "root": "",
      "sourceRoot": "src",
      "projectType": "application",
      "prefix": "app",
      "schematics": {},
      "architect": {
        "build": {
          "builder": "@angular-devkit/build-angular:browser",
          "options": {
            "outputPath": "dist/lazy-custom-element-app",
            "index": "src/index.html",
            "main": "src/main.ts",
            "polyfills": "src/polyfills.ts",
            "tsConfig": "src/tsconfig.app.json",
            "assets": [
              "src/favicon.ico",
              "src/assets"
            ],
            "styles": [
              "src/styles.css"
            ],
            "scripts": [],
            "lazyModules": [
              "src/app/lazy-load/lazy-load.module",
              "src/app/another-lazy-load/another-lazy-load.module"
            ]

тогда мы можем вызвать и загрузить наш скомпилированный модуль.

Как это:

export class LoaderComponent implements OnInit {

      // tag where we gonna inject the lazyload module and his default compononent "entry"
      @ViewChild('container', { read: ViewContainerRef }) viewRef: ViewContainerRef;

      constructor(
        private loader:     NgModuleFactoryLoader,
        private injector:   Injector,
        private moduleRef:  NgModuleRef<any>,) {
      }

      ngOnInit(): void {
       this.loader.load(this.pathModuleTemplate).then((moduleFactory: NgModuleFactory<any>) => {
          // our module had a static property 'entry' that references the component that  want to load by default with the module
          const entryComponent = (<any>moduleFactory.moduleType).entry;
          const moduleRef = moduleFactory.create(this.injector);
          const compFactory = moduleRef.componentFactoryResolver.resolveComponentFactory(entryComponent);
          this.viewRef.createComponent(compFactory);
        });
      }
}

источник: https://github.com/angular/angular-cli/blob/9107f3cc4e66b25721311b5c9272ec00c2dea46f/packages/angular_devkit/build_angular/src/server/schema.json

Надеюсь, это может помочь кому-то :)