@nova-ui/dashboards
Version:
Nova Dashboards is a framework designed to provide feature developers with a common solution for presenting data coming from various sources within a single view, as well as a set of predefined widget visualizations that are 100% configuration-driven and
306 lines • 49.4 kB
JavaScript
import { Directive, EventEmitter, Injector, Input, Output, Renderer2, SimpleChange, } from "@angular/core";
import isArray from "lodash/isArray";
import values from "lodash/values";
import xor from "lodash/xor";
import { ReplaySubject, Subject } from "rxjs";
import { takeUntil } from "rxjs/operators";
import { LoggerService } from "@nova-ui/bits";
import { ProviderRegistryService } from "../../../services/provider-registry.service";
import { ComponentPortalService } from "../../services/component-portal.service";
import * as i0 from "@angular/core";
import * as i1 from "@nova-ui/bits";
import * as i2 from "../../services/component-portal.service";
import * as i3 from "../../../services/provider-registry.service";
export class ComponentPortalDirective {
constructor(injector, logger, portalService, renderer, providerRegistry) {
this.injector = injector;
this.logger = logger;
this.portalService = portalService;
this.renderer = renderer;
this.providerRegistry = providerRegistry;
this.output = new EventEmitter();
this.propertiesChanges = new ReplaySubject();
this.providerInstances = {};
this.destroy$ = new Subject();
}
ngOnInit() {
this.logger.debug("Portal created:", this.componentId);
this.recreatePortal();
}
ngAfterViewInit() {
Object.keys(this.providerInstances).forEach((key) => {
const provider = this.providerInstances[key];
if (provider.ngAfterViewInit) {
provider.ngAfterViewInit();
}
});
}
ngOnChanges(changes) {
let recreated = false;
const providersChange = changes.providers;
if (providersChange && !providersChange.isFirstChange()) {
if (this.checkForProviderChanges(providersChange)) {
this.logger.debug("Portal recreated (provider change):", this.componentId);
this.recreatePortal();
recreated = true; // we want to prevent multiple recreations within one ngOnChanges cycle
}
else {
this.updateProviderConfigurations(providersChange);
}
}
if (changes.componentType &&
!changes.componentType.isFirstChange() &&
!recreated) {
this.logger.debug("Portal recreated (component change):", this.componentId);
this.recreatePortal();
}
if (changes.properties) {
this.propertiesChanges.next(changes.properties);
}
}
ngOnDestroy() {
this.logger.debug("Portal destroyed:", this.componentId);
this.destroyProviders();
this.listenerUnsubscriber?.();
this.destroy$.next();
this.destroy$.complete();
}
attached(componentRef) {
this.component = componentRef.instance;
// ctrl+shift+click on a pizzagna to get a dump of its properties
// this will propagate through the parent components, so it should dump the parent pizzagnas as well
this.listenerUnsubscriber = this.renderer.listen(componentRef.location.nativeElement, "click", (event) => {
// event.metaKey is a CMD key for Mac
if ((event.ctrlKey || event.metaKey) &&
event.shiftKey &&
event.button === 0) {
console.log("==================== PIZZAGNA DUMP =========================");
console.log("componentId:", this.componentId);
console.log("component:", this.component);
console.log("componentType:", this.componentType);
console.log("properties:", this.properties);
console.log("providers:", this.providers);
console.log("providerInstances:", this.providerInstances);
console.log("============================================================");
}
});
for (const key of Object.keys(this.providerInstances)) {
const provider = this.providerInstances[key];
if (provider.setComponent) {
// setting componentId separately because "componentId" is used as another input,
// at the moment of setting the component here, 'this.component' doesn't have 'componentId' property,
// because 'changesSubscription' has not received any changes. it leads to the issue
// when providers do not know the ID until component property changed
provider.setComponent(this.component, this.componentId);
}
if (provider.setProviders) {
provider.setProviders(this.providerInstances, this.componentId);
}
}
this.subscribeToOutputs();
this.changesSubscription = this.propertiesChanges
.pipe(takeUntil(this.destroy$))
.subscribe((change) => this.applyPropertiesChange(change));
}
recreatePortal() {
if (this.changesSubscription) {
this.changesSubscription.unsubscribe();
this.changesSubscription = undefined;
this.propertiesChanges = new ReplaySubject();
}
let injector = this.injector;
this.destroyProviders();
if (this.providers) {
injector = this.updateProviders(injector);
}
this.portal = this.portalService.createComponentPortal(this.componentType, injector);
// apply initial property values to the freshly (re)created component
if (this.properties) {
// eslint-disable-next-line @typescript-eslint/no-unused-vars
for (const key of Object.keys(this.properties)) {
this.propertiesChanges.next(new SimpleChange(undefined, this.properties, true));
}
}
}
updateProviders(injector) {
const providerKeys = Object.keys(this.providers);
const registeredProviders = providerKeys.reduce((acc, next) => {
// for cases when providerId is just empty string, null or undefined (for example adding a tile doesn't provide a DS to it)
if (this.providers[next].providerId) {
acc[next] = this.providerRegistry.getProvider(this.providers[next].providerId);
}
return acc;
}, {});
const portalInjector = this.portalService.createInjector({
injector: injector,
providers: values(registeredProviders),
});
this.providerInstances = providerKeys.reduce((acc, next) => {
const registeredProvider = registeredProviders[next];
const providerConfig = this.providers[next];
if (registeredProvider) {
// TODO: Why do we pass null to the injectFlags parameter?
// TODO: How to retrieve info about the provider options to inject?InjectOptions
const injections = portalInjector.get(registeredProvider.provide, null);
const providerInstance = isArray(injections)
? injections.find((v) => v instanceof registeredProvider.useClass)
: injections;
if (!providerInstance) {
throw new Error("Provider '" + next + "' does not exist.");
}
if (providerInstance.updateConfiguration &&
providerConfig.properties) {
providerInstance.updateConfiguration({
providerKey: next,
...(providerConfig.properties || {}),
});
}
providerInstance.providerKey = next;
acc[next] = providerInstance;
}
else if (providerConfig.providerId) {
this.logger.error("There's no registered provider for id", next);
}
return acc;
}, this.providerInstances);
for (const key of Object.keys(this.providerInstances)) {
const pi = this.providerInstances[key];
if (pi.ngOnInit) {
pi.ngOnInit();
}
}
return portalInjector;
}
updateProviderConfigurations(providersChange) {
for (const providerKey of Object.keys(this.providers)) {
// for cases when providerId is just empty string, null or undefined (for example adding a tile doesn't provide a DS to it)
if (!this.providers[providerKey].providerId) {
return;
}
const providerInstance = this.providerInstances[providerKey];
if (!providerInstance) {
throw new Error("Provider '" + providerKey + "' does not exist.");
}
const previousValue = providersChange.previousValue[providerKey];
const currentValue = providersChange.currentValue[providerKey];
const previousProperties = previousValue && previousValue.properties;
const currentProperties = currentValue && currentValue.properties;
if (previousProperties !== currentProperties &&
providerInstance.updateConfiguration) {
providerInstance.updateConfiguration({
providerKey,
...currentProperties,
});
}
}
}
subscribeToOutputs() {
if (!this.outputs) {
return;
}
for (const output of this.outputs.filter((o) => this.component[o] instanceof EventEmitter)) {
this.component[output]
.pipe(takeUntil(this.destroy$))
.subscribe(($event) => {
this.output.emit({
id: output,
payload: $event,
});
});
}
}
checkForProviderChanges(change) {
const previousKeys = change.previousValue
? Object.keys(change.previousValue)
: [];
const currentKeys = change.currentValue
? Object.keys(change.currentValue)
: [];
if (previousKeys.length !== currentKeys.length ||
xor(previousKeys, currentKeys).length > 0) {
return true;
}
const previousIds = Object.keys(change.previousValue).map((key) => change.previousValue[key].providerId);
const currentIds = Object.keys(change.currentValue).map((key) => change.currentValue[key].providerId);
if (xor(previousIds, currentIds).length > 0) {
return true;
}
return false;
}
destroyProviders() {
if (this.providerInstances) {
for (const piKey of Object.keys(this.providerInstances)) {
const providerInstance = this.providerInstances[piKey];
if (providerInstance.ngOnDestroy) {
providerInstance.ngOnDestroy();
}
delete this.providerInstances[piKey];
}
}
}
/**
* There was a change in component properties, so we need to handle that here
*
* @param change a change of the `properties` input
*/
applyPropertiesChange(change) {
let properties = change.currentValue;
if (!properties) {
return;
}
// we add componentId to the mix, so components will be able to use it
properties = {
...properties,
componentId: this.componentId,
};
const changes = {};
let changeHappened = false;
for (const key of Object.keys(properties)) {
const previousValue = this.component[key];
// reference based change detection in action here!
if (properties[key] !== previousValue) {
changeHappened = true;
this.component[key] = properties[key];
// we're simulating angular by calling ngOnChanges manually
if (this.component.ngOnChanges) {
changes[key] = new SimpleChange(previousValue, properties[key], change.isFirstChange());
}
}
}
if (changeHappened) {
if (this.component.ngOnChanges) {
this.component.ngOnChanges(changes);
}
const changeDetector = this.component.changeDetector;
if (changeDetector) {
changeDetector.markForCheck();
}
else {
this.logger.warn(`Property 'changeDetector' is missing on component '${this.componentType}',` +
` so dynamic refresh of given component might not work.`);
}
}
}
/** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ComponentPortalDirective, deps: [{ token: i0.Injector }, { token: i1.LoggerService }, { token: i2.ComponentPortalService }, { token: i0.Renderer2 }, { token: i3.ProviderRegistryService }], target: i0.ɵɵFactoryTarget.Directive }); }
/** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: ComponentPortalDirective, selector: "[nuiComponentPortal]", inputs: { componentId: "componentId", componentType: "componentType", properties: "properties", providers: "providers", outputs: "outputs" }, outputs: { output: "output" }, exportAs: ["nuiComponentPortal"], usesOnChanges: true, ngImport: i0 }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ComponentPortalDirective, decorators: [{
type: Directive,
args: [{
selector: "[nuiComponentPortal]",
exportAs: "nuiComponentPortal",
}]
}], ctorParameters: () => [{ type: i0.Injector }, { type: i1.LoggerService }, { type: i2.ComponentPortalService }, { type: i0.Renderer2 }, { type: i3.ProviderRegistryService }], propDecorators: { componentId: [{
type: Input
}], componentType: [{
type: Input
}], properties: [{
type: Input
}], providers: [{
type: Input
}], outputs: [{
type: Input
}], output: [{
type: Output
}] } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component-portal.directive.js","sourceRoot":"","sources":["../../../../../../src/lib/pizzagna/directives/component-portal/component-portal.directive.ts"],"names":[],"mappings":"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","sourcesContent":["// © 2022 SolarWinds Worldwide, LLC. All rights reserved.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n//  of this software and associated documentation files (the \"Software\"), to\n//  deal in the Software without restriction, including without limitation the\n//  rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n//  sell copies of the Software, and to permit persons to whom the Software is\n//  furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n//  all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n//  THE SOFTWARE.\n\nimport { Portal } from \"@angular/cdk/portal\";\nimport {\n    AfterViewInit,\n    ComponentRef,\n    Directive,\n    EventEmitter,\n    Injector,\n    Input,\n    OnChanges,\n    OnDestroy,\n    OnInit,\n    Output,\n    Renderer2,\n    SimpleChange,\n    SimpleChanges,\n    StaticProvider,\n} from \"@angular/core\";\nimport isArray from \"lodash/isArray\";\nimport values from \"lodash/values\";\nimport xor from \"lodash/xor\";\nimport { ReplaySubject, Subject, Subscription } from \"rxjs\";\nimport { takeUntil } from \"rxjs/operators\";\n\nimport { IEvent, LoggerService } from \"@nova-ui/bits\";\n\nimport { ProviderRegistryService } from \"../../../services/provider-registry.service\";\nimport { IConfigurable, IProviderConfiguration } from \"../../../types\";\nimport { ComponentPortalService } from \"../../services/component-portal.service\";\n\n@Directive({\n    selector: \"[nuiComponentPortal]\",\n    exportAs: \"nuiComponentPortal\",\n})\nexport class ComponentPortalDirective\n    implements OnInit, AfterViewInit, OnDestroy, OnChanges\n{\n    @Input() public componentId: string;\n    @Input() public componentType: string | Function;\n    @Input() public properties: Record<string, any>;\n    @Input() public providers: Record<string, IProviderConfiguration>;\n    @Input() public outputs: string[];\n\n    @Output() public output = new EventEmitter<IEvent>();\n\n    public portal: Portal<any>;\n    private component: any;\n    private propertiesChanges = new ReplaySubject<SimpleChange>();\n    private providerInstances: Record<string, any> = {};\n    private readonly destroy$ = new Subject<void>();\n    private changesSubscription?: Subscription;\n    private listenerUnsubscriber?: () => void;\n\n    constructor(\n        private injector: Injector,\n        private logger: LoggerService,\n        private portalService: ComponentPortalService,\n        private renderer: Renderer2,\n        private providerRegistry: ProviderRegistryService\n    ) {}\n\n    public ngOnInit(): void {\n        this.logger.debug(\"Portal created:\", this.componentId);\n        this.recreatePortal();\n    }\n\n    public ngAfterViewInit(): void {\n        Object.keys(this.providerInstances).forEach((key) => {\n            const provider = this.providerInstances[key];\n            if (provider.ngAfterViewInit) {\n                provider.ngAfterViewInit();\n            }\n        });\n    }\n\n    public ngOnChanges(changes: SimpleChanges): void {\n        let recreated = false;\n        const providersChange = changes.providers;\n\n        if (providersChange && !providersChange.isFirstChange()) {\n            if (this.checkForProviderChanges(providersChange)) {\n                this.logger.debug(\n                    \"Portal recreated (provider change):\",\n                    this.componentId\n                );\n                this.recreatePortal();\n                recreated = true; // we want to prevent multiple recreations within one ngOnChanges cycle\n            } else {\n                this.updateProviderConfigurations(providersChange);\n            }\n        }\n\n        if (\n            changes.componentType &&\n            !changes.componentType.isFirstChange() &&\n            !recreated\n        ) {\n            this.logger.debug(\n                \"Portal recreated (component change):\",\n                this.componentId\n            );\n            this.recreatePortal();\n        }\n\n        if (changes.properties) {\n            this.propertiesChanges.next(changes.properties);\n        }\n    }\n\n    public ngOnDestroy(): void {\n        this.logger.debug(\"Portal destroyed:\", this.componentId);\n\n        this.destroyProviders();\n        this.listenerUnsubscriber?.();\n\n        this.destroy$.next();\n        this.destroy$.complete();\n    }\n\n    public attached(componentRef: ComponentRef<any>): void {\n        this.component = componentRef.instance;\n\n        // ctrl+shift+click on a pizzagna to get a dump of its properties\n        // this will propagate through the parent components, so it should dump the parent pizzagnas as well\n        this.listenerUnsubscriber = this.renderer.listen(\n            componentRef.location.nativeElement,\n            \"click\",\n            (event: MouseEvent) => {\n                // event.metaKey is a CMD key for Mac\n                if (\n                    (event.ctrlKey || event.metaKey) &&\n                    event.shiftKey &&\n                    event.button === 0\n                ) {\n                    console.log(\n                        \"==================== PIZZAGNA DUMP =========================\"\n                    );\n                    console.log(\"componentId:\", this.componentId);\n                    console.log(\"component:\", this.component);\n                    console.log(\"componentType:\", this.componentType);\n                    console.log(\"properties:\", this.properties);\n                    console.log(\"providers:\", this.providers);\n                    console.log(\"providerInstances:\", this.providerInstances);\n                    console.log(\n                        \"============================================================\"\n                    );\n                }\n            }\n        );\n\n        for (const key of Object.keys(this.providerInstances)) {\n            const provider = this.providerInstances[key];\n            if (provider.setComponent) {\n                // setting componentId separately because \"componentId\" is used as another input,\n                // at the moment of setting the component here, 'this.component' doesn't have 'componentId' property,\n                // because 'changesSubscription' has not received any changes. it leads to the issue\n                // when providers do not know the ID until component property changed\n                provider.setComponent(this.component, this.componentId);\n            }\n            if (provider.setProviders) {\n                provider.setProviders(this.providerInstances, this.componentId);\n            }\n        }\n\n        this.subscribeToOutputs();\n\n        this.changesSubscription = this.propertiesChanges\n            .pipe(takeUntil(this.destroy$))\n            .subscribe((change) => this.applyPropertiesChange(change));\n    }\n\n    private recreatePortal() {\n        if (this.changesSubscription) {\n            this.changesSubscription.unsubscribe();\n            this.changesSubscription = undefined;\n            this.propertiesChanges = new ReplaySubject<SimpleChange>();\n        }\n\n        let injector = this.injector;\n\n        this.destroyProviders();\n\n        if (this.providers) {\n            injector = this.updateProviders(injector);\n        }\n\n        this.portal = this.portalService.createComponentPortal(\n            this.componentType,\n            injector\n        );\n\n        // apply initial property values to the freshly (re)created component\n        if (this.properties) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            for (const key of Object.keys(this.properties)) {\n                this.propertiesChanges.next(\n                    new SimpleChange(undefined, this.properties, true)\n                );\n            }\n        }\n    }\n\n    private updateProviders(injector: Injector) {\n        const providerKeys = Object.keys(this.providers);\n        const registeredProviders = providerKeys.reduce((acc, next) => {\n            // for cases when providerId is just empty string, null or undefined (for example adding a tile doesn't provide a DS to it)\n            if (this.providers[next].providerId) {\n                acc[next] = this.providerRegistry.getProvider(\n                    this.providers[next].providerId\n                );\n            }\n            return acc;\n        }, {} as Record<string, StaticProvider>);\n\n        const portalInjector = this.portalService.createInjector({\n            injector: injector,\n            providers: values(registeredProviders),\n        });\n\n        this.providerInstances = providerKeys.reduce((acc, next) => {\n            const registeredProvider = registeredProviders[next] as any;\n            const providerConfig = this.providers[next];\n            if (registeredProvider) {\n                // TODO: Why do we pass null to the injectFlags parameter?\n                // TODO: How to retrieve info about the provider options to inject?InjectOptions\n                const injections = portalInjector.get(\n                    registeredProvider.provide,\n                    null\n                );\n                const providerInstance = isArray(injections)\n                    ? (injections as any).find(\n                          (v: any) => v instanceof registeredProvider.useClass\n                      )\n                    : injections;\n\n                if (!providerInstance) {\n                    throw new Error(\"Provider '\" + next + \"' does not exist.\");\n                }\n                if (\n                    providerInstance.updateConfiguration &&\n                    providerConfig.properties\n                ) {\n                    providerInstance.updateConfiguration({\n                        providerKey: next,\n                        ...(providerConfig.properties || {}),\n                    });\n                }\n                providerInstance.providerKey = next;\n\n                acc[next] = providerInstance;\n            } else if (providerConfig.providerId) {\n                this.logger.error(\n                    \"There's no registered provider for id\",\n                    next\n                );\n            }\n            return acc;\n        }, this.providerInstances);\n\n        for (const key of Object.keys(this.providerInstances)) {\n            const pi = this.providerInstances[key];\n            if (pi.ngOnInit) {\n                pi.ngOnInit();\n            }\n        }\n\n        return portalInjector;\n    }\n\n    private updateProviderConfigurations(providersChange: SimpleChange) {\n        for (const providerKey of Object.keys(this.providers)) {\n            // for cases when providerId is just empty string, null or undefined (for example adding a tile doesn't provide a DS to it)\n            if (!this.providers[providerKey].providerId) {\n                return;\n            }\n            const providerInstance = this.providerInstances[providerKey];\n            if (!providerInstance) {\n                throw new Error(\n                    \"Provider '\" + providerKey + \"' does not exist.\"\n                );\n            }\n\n            const previousValue = providersChange.previousValue[providerKey];\n            const currentValue = providersChange.currentValue[providerKey];\n\n            const previousProperties =\n                previousValue && previousValue.properties;\n            const currentProperties = currentValue && currentValue.properties;\n\n            if (\n                previousProperties !== currentProperties &&\n                providerInstance.updateConfiguration\n            ) {\n                (providerInstance as IConfigurable).updateConfiguration({\n                    providerKey,\n                    ...currentProperties,\n                });\n            }\n        }\n    }\n\n    private subscribeToOutputs() {\n        if (!this.outputs) {\n            return;\n        }\n\n        for (const output of this.outputs.filter(\n            (o) => this.component[o] instanceof EventEmitter\n        )) {\n            this.component[output]\n                .pipe(takeUntil(this.destroy$))\n                .subscribe(($event: any) => {\n                    this.output.emit({\n                        id: output,\n                        payload: $event,\n                    });\n                });\n        }\n    }\n\n    private checkForProviderChanges(change: SimpleChange): boolean {\n        const previousKeys = change.previousValue\n            ? Object.keys(change.previousValue)\n            : [];\n        const currentKeys = change.currentValue\n            ? Object.keys(change.currentValue)\n            : [];\n        if (\n            previousKeys.length !== currentKeys.length ||\n            xor(previousKeys, currentKeys).length > 0\n        ) {\n            return true;\n        }\n\n        const previousIds = Object.keys(change.previousValue).map(\n            (key: string) => change.previousValue[key].providerId\n        );\n        const currentIds = Object.keys(change.currentValue).map(\n            (key: string) => change.currentValue[key].providerId\n        );\n        if (xor(previousIds, currentIds).length > 0) {\n            return true;\n        }\n\n        return false;\n    }\n\n    private destroyProviders() {\n        if (this.providerInstances) {\n            for (const piKey of Object.keys(this.providerInstances)) {\n                const providerInstance = this.providerInstances[piKey];\n                if (providerInstance.ngOnDestroy) {\n                    providerInstance.ngOnDestroy();\n                }\n                delete this.providerInstances[piKey];\n            }\n        }\n    }\n\n    /**\n     * There was a change in component properties, so we need to handle that here\n     *\n     * @param change a change of the `properties` input\n     */\n    private applyPropertiesChange(change: SimpleChange) {\n        let properties = change.currentValue;\n        if (!properties) {\n            return;\n        }\n\n        // we add componentId to the mix, so components will be able to use it\n        properties = {\n            ...properties,\n            componentId: this.componentId,\n        };\n\n        const changes: SimpleChanges = {};\n        let changeHappened = false;\n        for (const key of Object.keys(properties)) {\n            const previousValue = this.component[key];\n\n            // reference based change detection in action here!\n            if (properties[key] !== previousValue) {\n                changeHappened = true;\n                this.component[key] = properties[key];\n                // we're simulating angular by calling ngOnChanges manually\n                if (this.component.ngOnChanges) {\n                    changes[key] = new SimpleChange(\n                        previousValue,\n                        properties[key],\n                        change.isFirstChange()\n                    );\n                }\n            }\n        }\n\n        if (changeHappened) {\n            if (this.component.ngOnChanges) {\n                this.component.ngOnChanges(changes);\n            }\n            const changeDetector = this.component.changeDetector;\n            if (changeDetector) {\n                changeDetector.markForCheck();\n            } else {\n                this.logger.warn(\n                    `Property 'changeDetector' is missing on component '${this.componentType}',` +\n                        ` so dynamic refresh of given component might not work.`\n                );\n            }\n        }\n    }\n}\n"]}