public open(modalInstance: SkyModalInstance, component: any, providers?: any[]) {
let factory = this.resolver.resolveComponentFactory(component);
let hostService = new SkyModalHostService();
providers = providers || [];
providers.push({
provide: SkyModalHostService,
useValue: hostService
});
let resolvedProviders = ReflectiveInjector.resolve(providers);
let injector = ReflectiveInjector.fromResolvedProviders(resolvedProviders, this.injector);
let modalComponentRef = this.target.createComponent(factory, undefined, injector);
modalInstance.componentInstance = modalComponentRef.instance;
function closeModal() {
hostService.destroy();
modalComponentRef.destroy();
}
hostService.close.subscribe((modalComponent: SkyModalComponent) => {
closeModal();
});
modalInstance.setCloseCallback(() => {
closeModal();
});
}
return async(): Promise<BootstrapResponse> => {
try {
deferredLog('info', 'Bootstrapping server');
const resolvedProviders: ProviderType[] = await Promise.all(CORE_PROVIDERS.concat(providers));
//initialize all bootstrappers (in order they need to be created)
const resolvedBootstrappers: EntityBootstrapper[] = [
new ModelBootstrapper,
new ServiceBootstrapper,
new MigrationBootstrapper,
new SeederBootstrapper,
new ControllerBootstrapper,
];
const bootrapperProviders: any[] = resolvedBootstrappers.reduce((result: any[], bootstrapper: EntityBootstrapper) => {
return result.concat(bootstrapper.getInjectableEntities());
}, []);
const mergedProviders = ReflectiveInjector.resolve(bootrapperProviders.concat(resolvedProviders));
const injector = ReflectiveInjector.fromResolvedProviders(mergedProviders);
logger = injector.get(Logger)
.source('bootstrap');
// iterate over any logs that have been deferred
deferredLogs.forEach((log: DeferredLog) => {
logger[log.level](...log.messages);
});
deferredLogs = []; //clear buffer
// iterate over all of the resolved bootstrappers, invoking the bootstrap to initialize the
// entities. iteration is completed in serial so that bootstrappers that depend on other
// entities won't invoke until those other entities are finished intializing
await resolvedBootstrappers.reduce(async(current: Promise<void>, next: EntityBootstrapper): Promise<void> => {
await current;
return Promise.resolve(next.setInjector(injector).invokeBootstrap());
}, Promise.resolve()); //initial value
// get vars for the bootstrapper
const server: Server = injector.get(Server);
let response = {injector, server, logger};
if (afterBootstrap) {
await afterBootstrap(response);
// await Promise.resolve(afterBootstrap(response));
return response;
}
return response;
} catch (e) {
handleBootstrapError(e, logger);
}
}
appendTopOfLocation(ComponentClass, location: ViewContainerRef, providers?: ResolvedReflectiveProvider[]): ComponentRef<any> {
let componentFactory = this.componentFactoryResolver.resolveComponentFactory(ComponentClass);
let parentInjector = location.parentInjector;
let childInjector: Injector = parentInjector;
if (providers && providers.length > 0) {
childInjector = ReflectiveInjector.fromResolvedProviders(providers, parentInjector);
}
return location.createComponent(componentFactory, 0, childInjector);
}
.then(cmpFactory => {
const vcr = this._viewContainer,
bindings = this._compileConfig.bindings,
ctxInjector = vcr.parentInjector;
const childInjector = Array.isArray(bindings) && bindings.length > 0 ?
ReflectiveInjector.fromResolvedProviders(bindings, ctxInjector) : ctxInjector;
return this.dialog.contentRef =
vcr.createComponent(cmpFactory, vcr.length, childInjector);
});
this._cr.resolveComponent(TooltipComponent).then((cmpFactory: ComponentFactory<TooltipComponent>) => {
// Create reflective injector to provide an instance of TooltipData
let providers = ReflectiveInjector.resolve([
{ provide: TooltipData, useValue: new TooltipData(el, text, align) },
]);
let injector = ReflectiveInjector.fromResolvedProviders(providers, this.viewContainer.parentInjector);
// Create the component, outputs a promise...
return this.viewContainer.createComponent(cmpFactory, this.viewContainer.length, injector);
}).then((cmpRef: ComponentRef<TooltipComponent>) => {
.then((componentFactory:ComponentFactory<T>) => {
const viewContainerRef = _viewContainerRef || this.getRootViewContainerRef();
let bindings = ReflectiveInjector.resolve([
new Provider(ComponentOptionsClass, {useValue: options})
]);
const ctxInjector = viewContainerRef.parentInjector;
const childInjector = Array.isArray(bindings) && bindings.length > 0 ?
ReflectiveInjector.fromResolvedProviders(bindings, ctxInjector) : ctxInjector;
return viewContainerRef.createComponent(componentFactory, viewContainerRef.length, childInjector);
});
/**
* Creates an instance of a Component and attaches it to the View Container found at the
* `location` specified as {@link ViewContainerRef}.
*
* You can optionally provide `providers` to configure the {@link Injector} provisioned for this
* Component Instance.
*
* Returns {@link ComponentRef} representing the newly created Component.
* @param ComponentClass - @Component class
* @param location - reference to the location
* @param providers - optional array of providers
* @returns {ComponentRef<T>} - returns ComponentRef<T>
*/
public appendNextToLocation<T>(ComponentClass:Type<T>,
location:ViewContainerRef,
providers?:ResolvedReflectiveProvider[]):ComponentRef<T> {
let componentFactory = this.componentFactoryResolver.resolveComponentFactory(ComponentClass);
let parentInjector = location.parentInjector;
let childInjector: Injector = parentInjector;
if (providers && providers.length > 0) {
childInjector = ReflectiveInjector.fromResolvedProviders(providers, parentInjector);
}
return location.createComponent(componentFactory, location.length, childInjector);
}
.then(factory => {
// Create Injector for Component
const injector = ReflectiveInjector.fromResolvedProviders([], this.vcRef.parentInjector);
// Create Component with factory and injector. 0 = index which determines where in the
// container the component will be rendered. 0 means it will be rendered starting at the
// beginning
const componentRef = this.vcRef.createComponent(factory, 0, injector, []);
// Define any parameters you want to pass to the newly generated component
componentRef.instance.item = this.item;
});
ngOnInit() {
//ValueProvider { provide: any; useValue: any;}
// let providers = [{ provide: "item", useValue: this.item }, { provide: "column", useValue: this.column }];
// let inputs = ReflectiveInjector.resolve(providers);
let injector = ReflectiveInjector.fromResolvedProviders([], this.vcRef.parentInjector);
let component;
if (this.column.cell) {
let factory = this.resolver.resolveComponentFactory(this.column.cell);
component = factory.create(injector);
} else {
let factory = this.resolver.resolveComponentFactory(DefaultCellComponent);
component = factory.create(injector);
}
component.instance.column = this.column;
component.instance.item = this.item;
this.vcRef.insert(component.hostView);
}
public open(modalInstance: SkyModalInstance, component: any, config?: IConfig) {
let params: IConfig = Object.assign({}, config);
let factory = this.resolver.resolveComponentFactory(component);
let hostService = new SkyModalHostService();
let adapter = this.adapter;
params.providers.push({
provide: SkyModalHostService,
useValue: hostService
});
params.providers.push({
provide: SkyModalConfiguation,
useValue: params
});
adapter.setPageScroll(SkyModalHostService.openModalCount > 0);
let providers = params.providers /* istanbul ignore next */ || [];
let resolvedProviders = ReflectiveInjector.resolve(providers);
let injector = ReflectiveInjector.fromResolvedProviders(resolvedProviders, this.injector);
let modalComponentRef = this.target.createComponent(factory, undefined, injector);
modalInstance.componentInstance = modalComponentRef.instance;
function closeModal() {
hostService.destroy();
adapter.setPageScroll(SkyModalHostService.openModalCount > 0);
modalComponentRef.destroy();
}
hostService.close.subscribe((modalComponent: SkyModalComponent) => {
closeModal();
});
modalInstance.setCloseCallback(() => {
closeModal();
});
}
