@spartacus/core
Version:
Spartacus - the core framework
155 lines • 22.9 kB
JavaScript
import { Injectable, InjectFlags, NgModuleFactory, } from '@angular/core';
import { combineLatest, from, of, queueScheduler, throwError, } from 'rxjs';
import { catchError, concatMap, map, observeOn, publishReplay, switchMap, switchMapTo, tap, } from 'rxjs/operators';
import { CombinedInjector } from '../util/combined-injector';
import { createFrom } from '../util/create-from';
import { ModuleInitializedEvent } from './events/module-initialized-event';
import { MODULE_INITIALIZER } from './tokens';
import * as i0 from "@angular/core";
import * as i1 from "../event/event.service";
/**
* Utility service for managing dynamic imports of Angular services
*/
export class LazyModulesService {
constructor(compiler, injector, events) {
this.compiler = compiler;
this.injector = injector;
this.events = events;
/**
* Expose lazy loaded module references
*/
this.modules$ = this.events
.get(ModuleInitializedEvent)
.pipe(map((event) => event.moduleRef), publishReplay());
this.dependencyModules = new Map();
this.eventSubscription = this.modules$.connect();
}
/**
* Resolves module instance based dynamic import wrapped in an arrow function
*
* New module instance will be created with each call.
*
* @param moduleFunc
* @param feature
*/
resolveModuleInstance(moduleFunc, feature, dependencyModuleRefs = []) {
let parentInjector;
if (!dependencyModuleRefs.length) {
parentInjector = this.injector;
}
else if (dependencyModuleRefs.length === 1) {
parentInjector = dependencyModuleRefs[0].injector;
}
else {
parentInjector = new CombinedInjector(this.injector, dependencyModuleRefs.map((moduleRef) => moduleRef.injector));
}
return this.resolveModuleFactory(moduleFunc).pipe(map(([moduleFactory]) => moduleFactory.create(parentInjector)), concatMap((moduleRef) => this.runModuleInitializersForModule(moduleRef)), tap((moduleRef) => this.events.dispatch(createFrom(ModuleInitializedEvent, {
feature,
moduleRef,
}))));
}
/**
* Returns dependency module instance and initializes it when needed.
*
* Module will be instantiated only once, at first request for a this specific module class
*/
resolveDependencyModuleInstance(moduleFunc) {
// We grab moduleFactory symbol from module function and if there is no
// such a module created yet, we create it and store it in a
// dependencyModules map
return this.resolveModuleFactory(moduleFunc).pipe(map(([moduleFactory, module]) => {
if (!this.dependencyModules.has(module)) {
const moduleRef = moduleFactory.create(this.injector);
this.dependencyModules.set(module, moduleRef);
}
return this.dependencyModules.get(module);
}), concatMap((moduleRef) => this.runModuleInitializersForModule(moduleRef)), tap((moduleRef) => this.events.dispatch(createFrom(ModuleInitializedEvent, {
moduleRef,
}))));
}
/**
* The purpose of this function is to run MODULE_INITIALIZER logic that can be provided
* by a lazy loaded module. The module is recieved as a function parameter.
* This function returns an Observable to the module reference passed as an argument.
*
* @param {NgModuleRef<any>} moduleRef
*
* @returns {Observable<NgModuleRef<any>>}
*/
runModuleInitializersForModule(moduleRef) {
const moduleInits = moduleRef.injector.get(MODULE_INITIALIZER, [], InjectFlags.Self);
const asyncInitPromises = this.runModuleInitializerFunctions(moduleInits);
if (asyncInitPromises.length) {
return from(Promise.all(asyncInitPromises)).pipe(catchError((error) => {
console.error('MODULE_INITIALIZER promise was rejected while lazy loading a module.', error);
return throwError(error);
}), switchMapTo(of(moduleRef)));
}
else {
return of(moduleRef);
}
}
/**
* This function accepts an array of functions and runs them all. For each function that returns a promise,
* the resulting promise is stored in an array of promises. That array of promises is returned.
* It is not required for the functions to return a Promise. All functions are run. The return values
* that are not a Promise are simply not stored and returned.
*
* @param {(() => any)[]} initFunctions An array of functions too be run.
*
* @return {Promise<any>[]} An array of Promise returned by the functions, if any,
*/
runModuleInitializerFunctions(initFunctions) {
const initPromises = [];
try {
if (initFunctions) {
for (let i = 0; i < initFunctions.length; i++) {
const initResult = initFunctions[i]();
if (this.isObjectPromise(initResult)) {
initPromises.push(initResult);
}
}
}
return initPromises;
}
catch (error) {
console.error(`MODULE_INITIALIZER init function throwed an error. `, error);
throw error;
}
}
/**
* Determine if the argument is shaped like a Promise
*/
isObjectPromise(obj) {
return !!obj && typeof obj.then === 'function';
}
/**
* Resolve any Angular module from an function that return module or moduleFactory
*/
resolveModuleFactory(moduleFunc) {
return from(moduleFunc()).pipe(switchMap((module) => module instanceof NgModuleFactory
? of([module, module])
: combineLatest([
// using compiler here is for jit compatibility, there is no overhead
// for aot production builds as it will be stubbed
from(this.compiler.compileModuleAsync(module)),
of(module),
])), observeOn(queueScheduler));
}
ngOnDestroy() {
if (this.eventSubscription) {
this.eventSubscription.unsubscribe();
}
// clean up all initialized dependency modules
this.dependencyModules.forEach((dependency) => dependency.destroy());
}
}
LazyModulesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: LazyModulesService, deps: [{ token: i0.Compiler }, { token: i0.Injector }, { token: i1.EventService }], target: i0.ɵɵFactoryTarget.Injectable });
LazyModulesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: LazyModulesService, providedIn: 'root' });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: LazyModulesService, decorators: [{
type: Injectable,
args: [{
providedIn: 'root',
}]
}], ctorParameters: function () { return [{ type: i0.Compiler }, { type: i0.Injector }, { type: i1.EventService }]; } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lazy-modules.service.js","sourceRoot":"","sources":["../../../../../projects/core/src/lazy-loading/lazy-modules.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Compiler,\n  Injectable,\n  InjectFlags,\n  Injector,\n  NgModuleFactory,\n  NgModuleRef,\n  OnDestroy,\n} from '@angular/core';\nimport {\n  combineLatest,\n  ConnectableObservable,\n  from,\n  Observable,\n  of,\n  queueScheduler,\n  Subscription,\n  throwError,\n} from 'rxjs';\nimport {\n  catchError,\n  concatMap,\n  map,\n  observeOn,\n  publishReplay,\n  switchMap,\n  switchMapTo,\n  tap,\n} from 'rxjs/operators';\nimport { EventService } from '../event/event.service';\nimport { CombinedInjector } from '../util/combined-injector';\nimport { createFrom } from '../util/create-from';\nimport { ModuleInitializedEvent } from './events/module-initialized-event';\nimport { MODULE_INITIALIZER } from './tokens';\n\n/**\n * Utility service for managing dynamic imports of Angular services\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class LazyModulesService implements OnDestroy {\n  /**\n   * Expose lazy loaded module references\n   */\n  readonly modules$: Observable<NgModuleRef<any>> = this.events\n    .get(ModuleInitializedEvent)\n    .pipe(\n      map((event) => event.moduleRef),\n      publishReplay()\n    );\n\n  private readonly dependencyModules = new Map<any, NgModuleRef<any>>();\n  private readonly eventSubscription: Subscription;\n\n  constructor(\n    protected compiler: Compiler,\n    protected injector: Injector,\n    protected events: EventService\n  ) {\n    this.eventSubscription = (\n      this.modules$ as ConnectableObservable<NgModuleRef<any>>\n    ).connect();\n  }\n\n  /**\n   * Resolves module instance based dynamic import wrapped in an arrow function\n   *\n   * New module instance will be created with each call.\n   *\n   * @param moduleFunc\n   * @param feature\n   */\n  public resolveModuleInstance(\n    moduleFunc: () => Promise<any>,\n    feature?: string,\n    dependencyModuleRefs: NgModuleRef<any>[] = []\n  ): Observable<NgModuleRef<any>> {\n    let parentInjector: Injector;\n\n    if (!dependencyModuleRefs.length) {\n      parentInjector = this.injector;\n    } else if (dependencyModuleRefs.length === 1) {\n      parentInjector = dependencyModuleRefs[0].injector;\n    } else {\n      parentInjector = new CombinedInjector(\n        this.injector,\n        dependencyModuleRefs.map((moduleRef) => moduleRef.injector)\n      );\n    }\n\n    return this.resolveModuleFactory(moduleFunc).pipe(\n      map(([moduleFactory]) => moduleFactory.create(parentInjector)),\n      concatMap((moduleRef) => this.runModuleInitializersForModule(moduleRef)),\n      tap((moduleRef) =>\n        this.events.dispatch(\n          createFrom(ModuleInitializedEvent, {\n            feature,\n            moduleRef,\n          })\n        )\n      )\n    );\n  }\n\n  /**\n   * Returns dependency module instance and initializes it when needed.\n   *\n   * Module will be instantiated only once, at first request for a this specific module class\n   */\n  public resolveDependencyModuleInstance(\n    moduleFunc: () => Promise<any>\n  ): Observable<NgModuleRef<any>> {\n    // We grab moduleFactory symbol from module function and if there is no\n    // such a module created yet, we create it and store it in a\n    // dependencyModules map\n    return this.resolveModuleFactory(moduleFunc).pipe(\n      map(([moduleFactory, module]) => {\n        if (!this.dependencyModules.has(module)) {\n          const moduleRef = moduleFactory.create(this.injector);\n          this.dependencyModules.set(module, moduleRef);\n        }\n\n        return this.dependencyModules.get(module);\n      }),\n      concatMap((moduleRef) => this.runModuleInitializersForModule(moduleRef)),\n      tap((moduleRef) =>\n        this.events.dispatch(\n          createFrom(ModuleInitializedEvent, {\n            moduleRef,\n          })\n        )\n      )\n    );\n  }\n\n  /**\n   * The purpose of this function is to run MODULE_INITIALIZER logic that can be provided\n   * by a lazy loaded module.  The module is recieved as a function parameter.\n   * This function returns an Observable to the module reference passed as an argument.\n   *\n   * @param {NgModuleRef<any>} moduleRef\n   *\n   * @returns {Observable<NgModuleRef<any>>}\n   */\n  public runModuleInitializersForModule(\n    moduleRef: NgModuleRef<any>\n  ): Observable<NgModuleRef<any>> {\n    const moduleInits: any[] = moduleRef.injector.get<any[]>(\n      MODULE_INITIALIZER,\n      [],\n      InjectFlags.Self\n    );\n    const asyncInitPromises: Promise<any>[] =\n      this.runModuleInitializerFunctions(moduleInits);\n    if (asyncInitPromises.length) {\n      return from(Promise.all(asyncInitPromises)).pipe(\n        catchError((error) => {\n          console.error(\n            'MODULE_INITIALIZER promise was rejected while lazy loading a module.',\n            error\n          );\n          return throwError(error);\n        }),\n        switchMapTo(of(moduleRef))\n      );\n    } else {\n      return of(moduleRef);\n    }\n  }\n\n  /**\n   * This function accepts an array of functions and runs them all. For each function that returns a promise,\n   * the resulting promise is stored in an array of promises.  That array of promises is returned.\n   * It is not required for the functions to return a Promise.  All functions are run.  The return values\n   * that are not a Promise are simply not stored and returned.\n   *\n   * @param {(() => any)[]} initFunctions An array of functions too be run.\n   *\n   * @return {Promise<any>[]} An array of Promise returned by the functions, if any,\n   */\n  public runModuleInitializerFunctions(\n    initFunctions: (() => any)[]\n  ): Promise<any>[] {\n    const initPromises: Promise<any>[] = [];\n    try {\n      if (initFunctions) {\n        for (let i = 0; i < initFunctions.length; i++) {\n          const initResult = initFunctions[i]();\n          if (this.isObjectPromise(initResult)) {\n            initPromises.push(initResult);\n          }\n        }\n      }\n      return initPromises;\n    } catch (error) {\n      console.error(\n        `MODULE_INITIALIZER init function throwed an error. `,\n        error\n      );\n      throw error;\n    }\n  }\n\n  /**\n   * Determine if the argument is shaped like a Promise\n   */\n  private isObjectPromise<T = any>(obj: any): obj is Promise<T> {\n    return !!obj && typeof obj.then === 'function';\n  }\n\n  /**\n   * Resolve any Angular module from an function that return module or moduleFactory\n   */\n  private resolveModuleFactory(\n    moduleFunc: () => Promise<any>\n  ): Observable<[NgModuleFactory<any>, any]> {\n    return from(moduleFunc()).pipe(\n      switchMap((module) =>\n        module instanceof NgModuleFactory\n          ? (of([module, module]) as Observable<[NgModuleFactory<any>, any]>)\n          : combineLatest([\n              // using compiler here is for jit compatibility, there is no overhead\n              // for aot production builds as it will be stubbed\n              from(this.compiler.compileModuleAsync(module as any)),\n              of(module),\n            ])\n      ),\n      observeOn(queueScheduler)\n    );\n  }\n\n  ngOnDestroy(): void {\n    if (this.eventSubscription) {\n      this.eventSubscription.unsubscribe();\n    }\n\n    // clean up all initialized dependency modules\n    this.dependencyModules.forEach((dependency) => dependency.destroy());\n  }\n}\n"]}