feat(preset): Implement basic preset module

src/preset/index.ts

@@ -1 +1,5 @@
+export { PresetType } from './preset-token';
+export * from './preset-method';
+export * from './preset.service';
 export * from './preset.module';
+export * from './preset-default.module';

src/preset/preset-default.module.ts

@@ -0,0 +1,15 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+
+import { createWithPresetMethodFor } from './preset-method';
+import { PresetService } from './preset.service';
+
+@NgModule({
+  imports: [CommonModule],
+  exports: [],
+  declarations: [],
+  providers: [PresetService],
+})
+export class PresetDefaultModule {
+  static withPreset = createWithPresetMethodFor(PresetDefaultModule);
+}

src/preset/preset-method.ts

@@ -0,0 +1,15 @@
+import { ANALYZE_FOR_ENTRY_COMPONENTS, ModuleWithProviders, Type } from '@angular/core';
+
+import { PRESET_TYPES_TOKEN, PresetType } from './preset-token';
+
+export function createWithPresetMethodFor<T = any>(moduleClass: Type<any>) {
+  return (presetType: PresetType<T>): ModuleWithProviders => {
+    return {
+      ngModule: moduleClass,
+      providers: [
+        { provide: PRESET_TYPES_TOKEN, useValue: presetType, multi: true },
+        { provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: presetType, multi: true },
+      ],
+    };
+  };
+}

src/preset/preset-token.ts

@@ -0,0 +1,6 @@
+import { InjectionToken, Type } from '@angular/core';
+
+// tslint:disable-next-line:no-empty-interface
+export interface PresetType<T = any> extends Type<T> { }
+
+export const PRESET_TYPES_TOKEN = new InjectionToken<PresetType[]>('PresetTypes');

src/preset/preset.module.ts

@@ -1,9 +1,12 @@
+import { CommonModule } from '@angular/common';
 import { NgModule } from '@angular/core';
 
+import { PresetService } from './preset.service';
+
 @NgModule({
-  imports: [],
+  imports: [CommonModule],
   exports: [],
   declarations: [],
-  providers: [],
+  providers: [PresetService],
 })
-export class PresetModule {}
+export class PresetModule { }

src/preset/preset.service.spec.ts

@@ -0,0 +1,21 @@
+import { inject, TestBed } from '@angular/core/testing';
+
+import { PRESET_TYPES_TOKEN } from './preset-token';
+import { PresetService } from './preset.service';
+
+class MockPreset { }
+
+describe('Service: Preset', () => {
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [
+        { provide: PRESET_TYPES_TOKEN, useValue: MockPreset, multi: true },
+        PresetService,
+      ]
+    });
+  });
+
+  it('should ...', inject([PresetService], (service: PresetService) => {
+    expect(service).toBeTruthy();
+  }));
+});

src/preset/preset.service.ts

@@ -0,0 +1,48 @@
+import { ComponentFactoryResolver, ComponentRef, Injectable, Injector, OnDestroy } from '@angular/core';
+
+import { PRESET_TYPES_TOKEN, PresetType } from './preset-token';
+
+@Injectable()
+export class PresetService implements OnDestroy {
+
+  private presetTypes = this.injector.get(PRESET_TYPES_TOKEN);
+  private presetCompRefs: ComponentRef<any>[] = [];
+  private finalPresetComp: any;
+
+  constructor(
+    private injector: Injector,
+    private compResolver: ComponentFactoryResolver,
+  ) { }
+
+  getPreset<T = any>(): T {
+    if (this.presetTypes.length && !this.presetCompRefs.length) {
+      this.presetCompRefs = this.presetTypes
+        .map(presetType => this.createCompFromType(presetType));
+    }
+
+    if (!this.finalPresetComp) {
+      this.finalPresetComp = this.mergeCompRefs(this.presetCompRefs);
+    }
+
+    return this.finalPresetComp;
+  }
+
+  /** @internal */
+  ngOnDestroy() {
+    this.presetCompRefs
+      .forEach(presetCompRef => presetCompRef.destroy());
+    this.presetCompRefs = [];
+  }
+
+  private createCompFromType<T>(type: PresetType<T>) {
+    return this.compResolver
+      .resolveComponentFactory(type)
+      .create(this.injector);
+  }
+
+  private mergeCompRefs<T>(compRefs: ComponentRef<T>[]): T {
+    return compRefs.reduce((comp, compRef) =>
+      Object.assign(comp, compRef.instance), {} as T);
+  }
+
+}