@veloceapps/sdk 4.0.21-0

package/esm2015/runtime/components/ui-runtime-preview/runtime-preview.component.js

@@ -0,0 +1,109 @@
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { ConfigurationContextMode, EntityUtil, RuntimeModel, SectionPathUtil, } from '@veloceapps/core';
+import { RuntimeMode } from '@veloceapps/sdk/core';
+import { combineLatest, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/runtime.service";
+import * as i2 from "../../services/product-model-cache.service";
+import * as i3 from "@veloceapps/api";
+import * as i4 from "@veloceapps/sdk/core";
+import * as i5 from "../ui-runtime/runtime.component";
+export class RuntimePreviewComponent {
+    constructor(runtimeService, modelCacheService, configurationApiService, contextService) {
+        this.runtimeService = runtimeService;
+        this.modelCacheService = modelCacheService;
+        this.configurationApiService = configurationApiService;
+        this.contextService = contextService;
+        this.destroy$ = new Subject();
+    }
+    set uiDefinition(value) {
+        this._uiDefinition = value;
+        this.initDefinition(value);
+    }
+    ngOnInit() {
+        if (!this.modelId) {
+            return;
+        }
+        this.modelCacheService
+            .getProductModel(this.modelId)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(container => {
+            this.productModelContainer = container;
+            if (this._uiDefinition) {
+                this.initDefinition(this._uiDefinition);
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    initDefinition(uiDefinition) {
+        if (!this.productModelContainer) {
+            return;
+        }
+        const initialisedUiDefinition = EntityUtil.clone(uiDefinition);
+        const externals = this.productModelContainer.main.externals;
+        if (externals) {
+            initialisedUiDefinition.externals = externals.reduce((trunk, variable) => {
+                var _a, _b;
+                return Object.assign(Object.assign({}, trunk), { [variable.name]: (_b = (_a = initialisedUiDefinition.externals) === null || _a === void 0 ? void 0 : _a[variable.name]) !== null && _b !== void 0 ? _b : '' });
+            }, {});
+        }
+        else {
+            delete initialisedUiDefinition.externals;
+        }
+        this.initialisedUiDefinition = initialisedUiDefinition;
+        this.launchRuntime();
+    }
+    onSolutionUpdated(lineItem) {
+        this.runtimeService.updateRuntime({ configurableRamp: lineItem });
+    }
+    launchRuntime() {
+        if (!this.modelId || !this.initialisedUiDefinition) {
+            return;
+        }
+        SectionPathUtil.updateSectionsPath(this.initialisedUiDefinition.sections);
+        const uiDefinition = EntityUtil.clone(this.initialisedUiDefinition);
+        combineLatest([
+            this.configurationApiService.getRuntimeDataByModelId(this.modelId),
+            this.contextService.create('TestId', ConfigurationContextMode.TEST),
+        ]).subscribe(([runtimeData]) => {
+            var _a;
+            const runtimeModel = RuntimeModel.create(runtimeData.types, runtimeData.products);
+            const rootType = Array.from(runtimeModel.components.values()).find(c => uiDefinition.rootType &&
+                runtimeModel.isEquals(c.typeName, uiDefinition.rootType) &&
+                EntityUtil.isPresent(c.productId));
+            if (rootType === null || rootType === void 0 ? void 0 : rootType.typeName) {
+                uiDefinition.rootType = rootType.typeName;
+            }
+            const contextProductId = rootType ? rootType.productId : undefined;
+            const context = {
+                modelId: (_a = this.modelId) !== null && _a !== void 0 ? _a : '',
+                uiDefinition: uiDefinition,
+                runtimeModel,
+                runtimeMode: RuntimeMode.TEST,
+                productId: contextProductId,
+                properties: uiDefinition.externals,
+            };
+            this.runtimeService.startRuntime(context, {});
+        });
+    }
+}
+RuntimePreviewComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RuntimePreviewComponent, deps: [{ token: i1.RuntimeService }, { token: i2.ProductModelCacheService }, { token: i3.ConfigurationApiService }, { token: i4.ContextService }], target: i0.ɵɵFactoryTarget.Component });
+RuntimePreviewComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: RuntimePreviewComponent, selector: "vl-runtime-preview", inputs: { modelId: "modelId", uiDefinition: "uiDefinition" }, ngImport: i0, template: "<vl-runtime (solutionUpdated)=\"onSolutionUpdated($event)\"></vl-runtime>\n", styles: [":host{flex-grow:1}\n"], components: [{ type: i5.RuntimeComponent, selector: "vl-runtime", outputs: ["solutionUpdated"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RuntimePreviewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vl-runtime-preview',
+                    templateUrl: 'runtime-preview.component.html',
+                    styleUrls: ['runtime-preview.component.scss'],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.RuntimeService }, { type: i2.ProductModelCacheService }, { type: i3.ConfigurationApiService }, { type: i4.ContextService }]; }, propDecorators: { modelId: [{
+                type: Input
+            }], uiDefinition: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime-preview.component.js","sourceRoot":"","sources":["../../../../../../../libs/sdk/runtime/components/ui-runtime-preview/runtime-preview.component.ts","../../../../../../../libs/sdk/runtime/components/ui-runtime-preview/runtime-preview.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, Input, OnDestroy, OnInit } from '@angular/core';\nimport { ConfigurationApiService } from '@veloceapps/api';\nimport {\n  ConfigurationContextMode,\n  EntityUtil,\n  LineItem,\n  ProductModelAttribute,\n  ProductModelsContainer,\n  RuntimeModel,\n  SectionPathUtil,\n  UIDefinition,\n} from '@veloceapps/core';\nimport { ContextService, RuntimeMode } from '@veloceapps/sdk/core';\nimport { Dictionary } from 'lodash';\nimport { combineLatest, Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\nimport { ProductModelCacheService } from '../../services/product-model-cache.service';\nimport { RuntimeService } from '../../services/runtime.service';\nimport { LegacyRuntimeContext } from '../../types';\n\n@Component({\n  selector: 'vl-runtime-preview',\n  templateUrl: 'runtime-preview.component.html',\n  styleUrls: ['runtime-preview.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class RuntimePreviewComponent implements OnInit, OnDestroy {\n  @Input() modelId?: string;\n  @Input() set uiDefinition(value: UIDefinition) {\n    this._uiDefinition = value;\n    this.initDefinition(value);\n  }\n\n  private _uiDefinition?: UIDefinition;\n  private initialisedUiDefinition?: UIDefinition;\n  private productModelContainer?: ProductModelsContainer;\n\n  private destroy$ = new Subject<void>();\n\n  constructor(\n    private runtimeService: RuntimeService,\n    private modelCacheService: ProductModelCacheService,\n    private configurationApiService: ConfigurationApiService,\n    private contextService: ContextService,\n  ) {}\n\n  public ngOnInit(): void {\n    if (!this.modelId) {\n      return;\n    }\n\n    this.modelCacheService\n      .getProductModel(this.modelId)\n      .pipe(takeUntil(this.destroy$))\n      .subscribe(container => {\n        this.productModelContainer = container;\n\n        if (this._uiDefinition) {\n          this.initDefinition(this._uiDefinition);\n        }\n      });\n  }\n\n  public ngOnDestroy(): void {\n    this.destroy$.next();\n    this.destroy$.complete();\n  }\n\n  public initDefinition(uiDefinition: UIDefinition): void {\n    if (!this.productModelContainer) {\n      return;\n    }\n\n    const initialisedUiDefinition = EntityUtil.clone(uiDefinition);\n\n    const externals: ProductModelAttribute[] = this.productModelContainer.main.externals;\n    if (externals) {\n      initialisedUiDefinition.externals = externals.reduce<Dictionary<string>>((trunk, variable) => {\n        return {\n          ...trunk,\n          [variable.name]: initialisedUiDefinition.externals?.[variable.name] ?? '',\n        };\n      }, {});\n    } else {\n      delete initialisedUiDefinition.externals;\n    }\n\n    this.initialisedUiDefinition = initialisedUiDefinition;\n\n    this.launchRuntime();\n  }\n\n  public onSolutionUpdated(lineItem: LineItem): void {\n    this.runtimeService.updateRuntime({ configurableRamp: lineItem });\n  }\n\n  private launchRuntime() {\n    if (!this.modelId || !this.initialisedUiDefinition) {\n      return;\n    }\n\n    SectionPathUtil.updateSectionsPath(this.initialisedUiDefinition.sections);\n\n    const uiDefinition = EntityUtil.clone(this.initialisedUiDefinition);\n\n    combineLatest([\n      this.configurationApiService.getRuntimeDataByModelId(this.modelId),\n      this.contextService.create('TestId', ConfigurationContextMode.TEST),\n    ]).subscribe(([runtimeData]) => {\n      const runtimeModel = RuntimeModel.create(runtimeData.types, runtimeData.products);\n      const rootType = Array.from(runtimeModel.components.values()).find(\n        c =>\n          uiDefinition.rootType &&\n          runtimeModel.isEquals(c.typeName, uiDefinition.rootType) &&\n          EntityUtil.isPresent(c.productId),\n      );\n\n      if (rootType?.typeName) {\n        uiDefinition.rootType = rootType.typeName;\n      }\n\n      const contextProductId = rootType ? rootType.productId : undefined;\n\n      const context: LegacyRuntimeContext = {\n        modelId: this.modelId ?? '',\n        uiDefinition: uiDefinition,\n        runtimeModel,\n        runtimeMode: RuntimeMode.TEST,\n        productId: contextProductId,\n        properties: uiDefinition.externals,\n      };\n\n      this.runtimeService.startRuntime(context, {});\n    });\n  }\n}\n","<vl-runtime (solutionUpdated)=\"onSolutionUpdated($event)\"></vl-runtime>\n"]}

package/esm2015/runtime/execution/components/children-placeholder/children-placeholder.component.js

@@ -0,0 +1,68 @@
+import { Component, Input } from '@angular/core';
+import { OrderByPipe } from '@veloceapps/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/section-scope.service";
+import * as i2 from "../../../services/form-scope.service";
+import * as i3 from "../../../services/collapsible-state.service";
+import * as i4 from "../execution-section-renderer/execution-section-renderer.component";
+import * as i5 from "@angular/common";
+export class ChildrenPlaceholderComponent {
+    constructor(sectionScope, formScope, collapsibleState) {
+        this.sectionScope = sectionScope;
+        this.formScope = formScope;
+        this.collapsibleState = collapsibleState;
+        this._children = [];
+        this.collapsed = false;
+    }
+    ngOnInit() {
+        this.section = this.sectionScope.section;
+        this.form = this.formScope.form;
+        this.collapsed = this.section.model ? this.collapsibleState.isCollapsedSection(this.section.model.id) : true;
+        this.sub = this.collapsibleState.collapseSectionEvent.subscribe(e => {
+            var _a;
+            const lineItemId = e[0];
+            if (((_a = this.section.model) === null || _a === void 0 ? void 0 : _a.id) === lineItemId) {
+                this.collapsed = e[1];
+            }
+        });
+        this.setChildren();
+    }
+    ngOnChanges(changes) {
+        var _a, _b;
+        if (!this.children || ((_a = changes.children) === null || _a === void 0 ? void 0 : _a.currentValue) !== ((_b = changes.children) === null || _b === void 0 ? void 0 : _b.previousValue)) {
+            this.setChildren();
+        }
+    }
+    setChildren() {
+        this._children = this.children ? this.children : this.section.children;
+    }
+    ngOnDestroy() {
+        this.sub.unsubscribe();
+    }
+}
+ChildrenPlaceholderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ChildrenPlaceholderComponent, deps: [{ token: i1.SectionScopeService }, { token: i2.FormScopeService }, { token: i3.CollapsibleStateService }], target: i0.ɵɵFactoryTarget.Component });
+ChildrenPlaceholderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: ChildrenPlaceholderComponent, selector: "children-placeholder", inputs: { children: "children" }, providers: [OrderByPipe], usesOnChanges: true, ngImport: i0, template: "<ng-container *ngIf=\"!collapsed\">\n  <ng-container *ngFor=\"let child of _children\">\n    <section-renderer [section]=\"child\" [form]=\"form\" *ngIf=\"!child.hidden\"></section-renderer>\n  </ng-container>\n</ng-container>\n", components: [{ type: i4.ExecutionSectionRendererComponent, selector: "section-renderer", inputs: ["section", "form"] }], directives: [{ type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ChildrenPlaceholderComponent, decorators: [{
+            type: Component,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/component-selector
+                    selector: 'children-placeholder',
+                    templateUrl: 'children-placeholder.component.html',
+                    providers: [OrderByPipe],
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SectionScopeService }, { type: i2.FormScopeService }, { type: i3.CollapsibleStateService }]; }, propDecorators: { children: [{
+                type: Input
+            }] } });
+export class TemplateComponent extends ChildrenPlaceholderComponent {
+}
+TemplateComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: TemplateComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+TemplateComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: TemplateComponent, selector: "template-component", usesInheritance: true, ngImport: i0, template: "<ng-container *ngIf=\"!collapsed\">\n  <ng-container *ngFor=\"let child of _children\">\n    <section-renderer [section]=\"child\" [form]=\"form\" *ngIf=\"!child.hidden\"></section-renderer>\n  </ng-container>\n</ng-container>\n", components: [{ type: i4.ExecutionSectionRendererComponent, selector: "section-renderer", inputs: ["section", "form"] }], directives: [{ type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: TemplateComponent, decorators: [{
+            type: Component,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/component-selector
+                    selector: 'template-component',
+                    templateUrl: 'children-placeholder.component.html',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/runtime/execution/components/context-provider/context-provider.component.js

@@ -0,0 +1,36 @@
+import { Component, Inject, Input } from '@angular/core';
+import { RuntimeModel } from '@veloceapps/core';
+import { RuntimeService } from '../../../services/runtime.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/runtime.service";
+export class ContextProviderComponent {
+    constructor(runtimeService) {
+        this.runtimeService = runtimeService;
+        this.types = [];
+        this.products = {};
+    }
+    ngOnInit() {
+        const context = this.runtimeService.getRuntimeContext();
+        if (!context) {
+            return;
+        }
+        this.runtimeService.setRuntimeContext(Object.assign(Object.assign({}, context), { runtimeModel: RuntimeModel.create(this.types, this.products) }));
+    }
+}
+ContextProviderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ContextProviderComponent, deps: [{ token: RuntimeService }], target: i0.ɵɵFactoryTarget.Component });
+ContextProviderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: ContextProviderComponent, selector: "vl-context-provider", inputs: { types: "types", products: "products" }, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ContextProviderComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vl-context-provider',
+                    template: '',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.RuntimeService, decorators: [{
+                    type: Inject,
+                    args: [RuntimeService]
+                }] }]; }, propDecorators: { types: [{
+                type: Input
+            }], products: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/runtime/execution/components/execution-section-renderer/execution-section-renderer.component.js

@@ -0,0 +1,72 @@
+import { Component, Input, ViewChild, ViewContainerRef, } from '@angular/core';
+import { SectionScopeService } from '../../../services/section-scope.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/section-scope.service";
+import * as i2 from "../../../services/section-store.service";
+export class ExecutionSectionRendererComponent {
+    constructor(_injector, _m, sectionScope, sectionStore) {
+        this._injector = _injector;
+        this._m = _m;
+        this.sectionScope = sectionScope;
+        this.sectionStore = sectionStore;
+        this.componentRef = null;
+    }
+    set section(value) {
+        this._section = value;
+        this.sectionScope.section = value;
+    }
+    get section() {
+        return this._section;
+    }
+    ngOnInit() {
+        this.renderSection();
+    }
+    ngAfterViewInit() {
+        var _a, _b;
+        if (this.componentRef) {
+            this.sectionScope.templates.next((_b = (_a = this.componentRef.instance['templates']) === null || _a === void 0 ? void 0 : _a.toArray()) !== null && _b !== void 0 ? _b : []);
+        }
+    }
+    ngOnDestroy() {
+        if (this.componentRef) {
+            this.componentRef.destroy();
+            this.componentRef = null;
+        }
+    }
+    renderSection() {
+        var _a;
+        if (this.componentRef) {
+            this.componentRef.destroy();
+            this.componentRef = null;
+        }
+        const componentFactory = this.sectionStore.getComponentFactory(this._section);
+        if (!componentFactory) {
+            return;
+        }
+        this.componentRef = componentFactory.create(this._injector, [], null, this._m);
+        this.componentRef.location.nativeElement.setAttribute('sectionId', `${(_a = this._section.model) === null || _a === void 0 ? void 0 : _a.id}${this._section.label}`);
+        this.componentRef.instance['form'] = this.form;
+        this.componentRef.instance['section'] = this.section;
+        this.container.insert(this.componentRef.hostView);
+    }
+}
+ExecutionSectionRendererComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ExecutionSectionRendererComponent, deps: [{ token: i0.Injector }, { token: i0.NgModuleRef }, { token: i1.SectionScopeService }, { token: i2.SectionStoreService }], target: i0.ɵɵFactoryTarget.Component });
+ExecutionSectionRendererComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: ExecutionSectionRendererComponent, selector: "section-renderer", inputs: { section: "section", form: "form" }, providers: [SectionScopeService], viewQueries: [{ propertyName: "container", first: true, predicate: ["container"], descendants: true, read: ViewContainerRef, static: true }], ngImport: i0, template: "<ng-template #container></ng-template>", styles: [":host{display:contents}\n"] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ExecutionSectionRendererComponent, decorators: [{
+            type: Component,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/component-selector
+                    selector: 'section-renderer',
+                    templateUrl: 'execution-section-renderer.component.html',
+                    styleUrls: ['execution-section-renderer.component.scss'],
+                    providers: [SectionScopeService],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i0.NgModuleRef }, { type: i1.SectionScopeService }, { type: i2.SectionStoreService }]; }, propDecorators: { section: [{
+                type: Input
+            }], form: [{
+                type: Input
+            }], container: [{
+                type: ViewChild,
+                args: ['container', { read: ViewContainerRef, static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhlY3V0aW9uLXNlY3Rpb24tcmVuZGVyZXIuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9zZGsvcnVudGltZS9leGVjdXRpb24vY29tcG9uZW50cy9leGVjdXRpb24tc2VjdGlvbi1yZW5kZXJlci9leGVjdXRpb24tc2VjdGlvbi1yZW5kZXJlci5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3Nkay9ydW50aW1lL2V4ZWN1dGlvbi9jb21wb25lbnRzL2V4ZWN1dGlvbi1zZWN0aW9uLXJlbmRlcmVyL2V4ZWN1dGlvbi1zZWN0aW9uLXJlbmRlcmVyLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFFTCxTQUFTLEVBR1QsS0FBSyxFQUlMLFNBQVMsRUFDVCxnQkFBZ0IsR0FDakIsTUFBTSxlQUFlLENBQUM7QUFHdkIsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0seUNBQXlDLENBQUM7Ozs7QUFVOUUsTUFBTSxPQUFPLGlDQUFpQztJQWdCNUMsWUFDVSxTQUFtQixFQUNuQixFQUFvQixFQUNwQixZQUFpQyxFQUNqQyxZQUFpQztRQUhqQyxjQUFTLEdBQVQsU0FBUyxDQUFVO1FBQ25CLE9BQUUsR0FBRixFQUFFLENBQWtCO1FBQ3BCLGlCQUFZLEdBQVosWUFBWSxDQUFxQjtRQUNqQyxpQkFBWSxHQUFaLFlBQVksQ0FBcUI7UUFNbkMsaUJBQVksR0FBNkIsSUFBSSxDQUFDO0lBTG5ELENBQUM7SUFsQkosSUFDSSxPQUFPLENBQUMsS0FBYztRQUN4QixJQUFJLENBQUMsUUFBUSxHQUFHLEtBQUssQ0FBQztRQUN0QixJQUFJLENBQUMsWUFBWSxDQUFDLE9BQU8sR0FBRyxLQUFLLENBQUM7SUFDcEMsQ0FBQztJQUVELElBQUksT0FBTztRQUNULE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQztJQUN2QixDQUFDO0lBaUJELFFBQVE7UUFDTixJQUFJLENBQUMsYUFBYSxFQUFFLENBQUM7SUFDdkIsQ0FBQztJQUVELGVBQWU7O1FBQ2IsSUFBSSxJQUFJLENBQUMsWUFBWSxFQUFFO1lBQ3JCLElBQUksQ0FBQyxZQUFZLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxNQUFBLE1BQUEsSUFBSSxDQUFDLFlBQVksQ0FBQyxRQUFRLENBQUMsV0FBVyxDQUFDLDBDQUFFLE9BQU8sRUFBRSxtQ0FBSSxFQUFFLENBQUMsQ0FBQztTQUM1RjtJQUNILENBQUM7SUFFRCxXQUFXO1FBQ1QsSUFBSSxJQUFJLENBQUMsWUFBWSxFQUFFO1lBQ3JCLElBQUksQ0FBQyxZQUFZLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDNUIsSUFBSSxDQUFDLFlBQVksR0FBRyxJQUFJLENBQUM7U0FDMUI7SUFDSCxDQUFDO0lBRUQsYUFBYTs7UUFDWCxJQUFJLElBQUksQ0FBQyxZQUFZLEVBQUU7WUFDckIsSUFBSSxDQUFDLFlBQVksQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUM1QixJQUFJLENBQUMsWUFBWSxHQUFHLElBQUksQ0FBQztTQUMxQjtRQUVELE1BQU0sZ0JBQWdCLEdBQUcsSUFBSSxDQUFDLFlBQVksQ0FBQyxtQkFBbUIsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDOUUsSUFBSSxDQUFDLGdCQUFnQixFQUFFO1lBQ3JCLE9BQU87U0FDUjtRQUVELElBQUksQ0FBQyxZQUFZLEdBQUcsZ0JBQWdCLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsRUFBRSxFQUFFLElBQUksRUFBRSxJQUFJLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDL0UsSUFBSSxDQUFDLFlBQVksQ0FBQyxRQUFRLENBQUMsYUFBYSxDQUFDLFlBQVksQ0FDbkQsV0FBVyxFQUNYLEdBQUcsTUFBQSxJQUFJLENBQUMsUUFBUSxDQUFDLEtBQUssMENBQUUsRUFBRSxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsS0FBSyxFQUFFLENBQ25ELENBQUM7UUFDRixJQUFJLENBQUMsWUFBWSxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDO1FBQy9DLElBQUksQ0FBQyxZQUFZLENBQUMsUUFBUSxDQUFDLFNBQVMsQ0FBQyxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUM7UUFDckQsSUFBSSxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUNwRCxDQUFDOzsrSEFoRVUsaUNBQWlDO21IQUFqQyxpQ0FBaUMseUZBRmpDLENBQUMsbUJBQW1CLENBQUMsNkdBeUJBLGdCQUFnQiwyQ0MvQ2xELHdDQUFzQzs0RkR3QnpCLGlDQUFpQztrQkFQN0MsU0FBUzttQkFBQztvQkFDVCw4REFBOEQ7b0JBQzlELFFBQVEsRUFBRSxrQkFBa0I7b0JBQzVCLFdBQVcsRUFBRSwyQ0FBMkM7b0JBQ3hELFNBQVMsRUFBRSxDQUFDLDJDQUEyQyxDQUFDO29CQUN4RCxTQUFTLEVBQUUsQ0FBQyxtQkFBbUIsQ0FBQztpQkFDakM7NkxBS0ssT0FBTztzQkFEVixLQUFLO2dCQVdOLElBQUk7c0JBREgsS0FBSztnQkFXTixTQUFTO3NCQURSLFNBQVM7dUJBQUMsV0FBVyxFQUFFLEVBQUUsSUFBSSxFQUFFLGdCQUFnQixFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuICBBZnRlclZpZXdJbml0LFxuICBDb21wb25lbnQsXG4gIENvbXBvbmVudFJlZixcbiAgSW5qZWN0b3IsXG4gIElucHV0LFxuICBOZ01vZHVsZVJlZixcbiAgT25EZXN0cm95LFxuICBPbkluaXQsXG4gIFZpZXdDaGlsZCxcbiAgVmlld0NvbnRhaW5lclJlZixcbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBGb3JtR3JvdXAgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5pbXBvcnQgeyBTZWN0aW9uIH0gZnJvbSAnQHZlbG9jZWFwcHMvY29yZSc7XG5pbXBvcnQgeyBTZWN0aW9uU2NvcGVTZXJ2aWNlIH0gZnJvbSAnLi4vLi4vLi4vc2VydmljZXMvc2VjdGlvbi1zY29wZS5zZXJ2aWNlJztcbmltcG9ydCB7IFNlY3Rpb25TdG9yZVNlcnZpY2UgfSBmcm9tICcuLi8uLi8uLi9zZXJ2aWNlcy9zZWN0aW9uLXN0b3JlLnNlcnZpY2UnO1xuXG5AQ29tcG9uZW50KHtcbiAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEBhbmd1bGFyLWVzbGludC9jb21wb25lbnQtc2VsZWN0b3JcbiAgc2VsZWN0b3I6ICdzZWN0aW9uLXJlbmRlcmVyJyxcbiAgdGVtcGxhdGVVcmw6ICdleGVjdXRpb24tc2VjdGlvbi1yZW5kZXJlci5jb21wb25lbnQuaHRtbCcsXG4gIHN0eWxlVXJsczogWydleGVjdXRpb24tc2VjdGlvbi1yZW5kZXJlci5jb21wb25lbnQuc2NzcyddLFxuICBwcm92aWRlcnM6IFtTZWN0aW9uU2NvcGVTZXJ2aWNlXSxcbn0pXG5leHBvcnQgY2xhc3MgRXhlY3V0aW9uU2VjdGlvblJlbmRlcmVyQ29tcG9uZW50IGltcGxlbWVudHMgT25Jbml0LCBBZnRlclZpZXdJbml0LCBPbkRlc3Ryb3kge1xuICBwcml2YXRlIF9zZWN0aW9uITogU2VjdGlvbjtcblxuICBASW5wdXQoKVxuICBzZXQgc2VjdGlvbih2YWx1ZTogU2VjdGlvbikge1xuICAgIHRoaXMuX3NlY3Rpb24gPSB2YWx1ZTtcbiAgICB0aGlzLnNlY3Rpb25TY29wZS5zZWN0aW9uID0gdmFsdWU7XG4gIH1cblxuICBnZXQgc2VjdGlvbigpOiBTZWN0aW9uIHtcbiAgICByZXR1cm4gdGhpcy5fc2VjdGlvbjtcbiAgfVxuXG4gIEBJbnB1dCgpXG4gIGZvcm0hOiBGb3JtR3JvdXA7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcHJpdmF0ZSBfaW5qZWN0b3I6IEluamVjdG9yLFxuICAgIHByaXZhdGUgX206IE5nTW9kdWxlUmVmPGFueT4sXG4gICAgcHJpdmF0ZSBzZWN0aW9uU2NvcGU6IFNlY3Rpb25TY29wZVNlcnZpY2UsXG4gICAgcHJpdmF0ZSBzZWN0aW9uU3RvcmU6IFNlY3Rpb25TdG9yZVNlcnZpY2UsXG4gICkge31cblxuICBAVmlld0NoaWxkKCdjb250YWluZXInLCB7IHJlYWQ6IFZpZXdDb250YWluZXJSZWYsIHN0YXRpYzogdHJ1ZSB9KVxuICBjb250YWluZXIhOiBWaWV3Q29udGFpbmVyUmVmO1xuXG4gIHByaXZhdGUgY29tcG9uZW50UmVmOiBDb21wb25lbnRSZWY8YW55PiB8IG51bGwgPSBudWxsO1xuXG4gIG5nT25Jbml0KCk6IHZvaWQge1xuICAgIHRoaXMucmVuZGVyU2VjdGlvbigpO1xuICB9XG5cbiAgbmdBZnRlclZpZXdJbml0KCkge1xuICAgIGlmICh0aGlzLmNvbXBvbmVudFJlZikge1xuICAgICAgdGhpcy5zZWN0aW9uU2NvcGUudGVtcGxhdGVzLm5leHQodGhpcy5jb21wb25lbnRSZWYuaW5zdGFuY2VbJ3RlbXBsYXRlcyddPy50b0FycmF5KCkgPz8gW10pO1xuICAgIH1cbiAgfVxuXG4gIG5nT25EZXN0cm95KCk6IHZvaWQge1xuICAgIGlmICh0aGlzLmNvbXBvbmVudFJlZikge1xuICAgICAgdGhpcy5jb21wb25lbnRSZWYuZGVzdHJveSgpO1xuICAgICAgdGhpcy5jb21wb25lbnRSZWYgPSBudWxsO1xuICAgIH1cbiAgfVxuXG4gIHJlbmRlclNlY3Rpb24oKTogdm9pZCB7XG4gICAgaWYgKHRoaXMuY29tcG9uZW50UmVmKSB7XG4gICAgICB0aGlzLmNvbXBvbmVudFJlZi5kZXN0cm95KCk7XG4gICAgICB0aGlzLmNvbXBvbmVudFJlZiA9IG51bGw7XG4gICAgfVxuXG4gICAgY29uc3QgY29tcG9uZW50RmFjdG9yeSA9IHRoaXMuc2VjdGlvblN0b3JlLmdldENvbXBvbmVudEZhY3RvcnkodGhpcy5fc2VjdGlvbik7XG4gICAgaWYgKCFjb21wb25lbnRGYWN0b3J5KSB7XG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgdGhpcy5jb21wb25lbnRSZWYgPSBjb21wb25lbnRGYWN0b3J5LmNyZWF0ZSh0aGlzLl9pbmplY3RvciwgW10sIG51bGwsIHRoaXMuX20pO1xuICAgIHRoaXMuY29tcG9uZW50UmVmLmxvY2F0aW9uLm5hdGl2ZUVsZW1lbnQuc2V0QXR0cmlidXRlKFxuICAgICAgJ3NlY3Rpb25JZCcsXG4gICAgICBgJHt0aGlzLl9zZWN0aW9uLm1vZGVsPy5pZH0ke3RoaXMuX3NlY3Rpb24ubGFiZWx9YCxcbiAgICApO1xuICAgIHRoaXMuY29tcG9uZW50UmVmLmluc3RhbmNlWydmb3JtJ10gPSB0aGlzLmZvcm07XG4gICAgdGhpcy5jb21wb25lbnRSZWYuaW5zdGFuY2VbJ3NlY3Rpb24nXSA9IHRoaXMuc2VjdGlvbjtcbiAgICB0aGlzLmNvbnRhaW5lci5pbnNlcnQodGhpcy5jb21wb25lbnRSZWYuaG9zdFZpZXcpO1xuICB9XG59XG4iLCI8bmctdGVtcGxhdGUgI2NvbnRhaW5lcj48L25nLXRlbXBsYXRlPiJdfQ==

package/esm2015/runtime/execution/components/federated/federated.component.js

@@ -0,0 +1,81 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, TemplateRef, ViewChild, ViewContainerRef, } from '@angular/core';
+import { loadRemoteModule } from '../../utils/federated.util';
+import * as i0 from "@angular/core";
+var IntegrationEvent;
+(function (IntegrationEvent) {
+    IntegrationEvent["Init"] = "Init";
+})(IntegrationEvent || (IntegrationEvent = {}));
+export class FederatedComponent {
+    constructor(injector, compiler, appRef, renderer) {
+        this.injector = injector;
+        this.compiler = compiler;
+        this.appRef = appRef;
+        this.renderer = renderer;
+        this.integrationEvent = new EventEmitter();
+        this.moduleReady = false;
+    }
+    ngAfterViewInit() {
+        if (!this.remoteEntry || !this.remoteName || !this.exposedModule) {
+            return;
+        }
+        loadRemoteModule({
+            remoteEntry: this.remoteEntry,
+            remoteName: this.remoteName,
+            exposedModule: this.exposedModule,
+        }).then(federated => {
+            this.compiler.compileModuleAsync(federated[this.exposedModule]).then(moduleFactory => {
+                var _a;
+                const rootModuleRef = moduleFactory.create(this.injector);
+                const rootComponentFactory = rootModuleRef.componentFactoryResolver.resolveComponentFactory(federated[this.exposedModule].rootComponent);
+                const node = document.createElement('div');
+                const { instance, hostView } = rootComponentFactory.create(this.injector, [], node);
+                this.instance = instance;
+                this.instance.data = this.data;
+                this.instance.eventData = this.eventData;
+                this.instance.integrationEvent = this.integrationEvent;
+                this.renderer.appendChild((_a = this.moduleHostRef) === null || _a === void 0 ? void 0 : _a.nativeElement, node);
+                this.appRef.attachView(hostView);
+            });
+        });
+    }
+    ngOnChanges(changes) {
+        if (!this.instance) {
+            return;
+        }
+        this.instance.ngOnChanges(changes);
+    }
+}
+FederatedComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FederatedComponent, deps: [{ token: i0.Injector }, { token: i0.Compiler }, { token: i0.ApplicationRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+FederatedComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: FederatedComponent, selector: "veloce-host-federated", inputs: { remoteEntry: "remoteEntry", remoteName: "remoteName", exposedModule: "exposedModule", data: "data", eventData: "eventData" }, outputs: { integrationEvent: "integrationEvent" }, viewQueries: [{ propertyName: "federatedComponent", first: true, predicate: ["federatedComponent"], descendants: true, read: ViewContainerRef }, { propertyName: "foo", first: true, predicate: ["foo"], descendants: true, read: TemplateRef }, { propertyName: "moduleHostRef", first: true, predicate: ["moduleHost"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div #moduleHost></div>\n", styles: [":host{display:block}div{height:100%}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FederatedComponent, decorators: [{
+            type: Component,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/component-selector
+                    selector: 'veloce-host-federated',
+                    templateUrl: './federated.component.html',
+                    styleUrls: ['./federated.component.scss'],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i0.Compiler }, { type: i0.ApplicationRef }, { type: i0.Renderer2 }]; }, propDecorators: { federatedComponent: [{
+                type: ViewChild,
+                args: ['federatedComponent', { read: ViewContainerRef }]
+            }], foo: [{
+                type: ViewChild,
+                args: ['foo', { read: TemplateRef }]
+            }], moduleHostRef: [{
+                type: ViewChild,
+                args: ['moduleHost', { static: false }]
+            }], remoteEntry: [{
+                type: Input
+            }], remoteName: [{
+                type: Input
+            }], exposedModule: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }], eventData: [{
+                type: Input
+            }], integrationEvent: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/runtime/execution/components/velo-attribute/velo-attribute.component.js

@@ -0,0 +1,65 @@
+import { Component } from '@angular/core';
+import { VeloAttributeDirective } from '../../directives/velo-attribute.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/form-scope.service";
+import * as i2 from "../../../services/section-scope.service";
+import * as i3 from "../velo-multiselect/velo-multiselect.component";
+import * as i4 from "@angular/forms";
+import * as i5 from "@angular/common";
+export class VeloAttributeComponent extends VeloAttributeDirective {
+    constructor(formScope, sectionScope) {
+        var _a, _b;
+        super(formScope, sectionScope);
+        this.controlName = this.section.id;
+        this.displayName = this.getDisplayName();
+        this.isMultiselect =
+            ((_b = (_a = this.section.model) === null || _a === void 0 ? void 0 : _a.attributes.find(attr => attr.name === this.section.boundData.entity.name)) === null || _b === void 0 ? void 0 : _b.type) ===
+                'MULTIPLE';
+    }
+    getValueOptions(valueOptions) {
+        return this.isBooleanType(valueOptions) ? [0, 1] : valueOptions;
+    }
+    getValueText(valueOptions, value) {
+        if (this.isBooleanType(valueOptions)) {
+            return value === 0 ? 'False' : 'True';
+        }
+        return value;
+    }
+    handleMultiselectChange(value) {
+        var _a;
+        const formControl = this.form.get(this.controlName);
+        if (!formControl) {
+            return;
+        }
+        const currentValue = (_a = formControl.value) !== null && _a !== void 0 ? _a : [];
+        const newValue = currentValue.includes(value) ? currentValue.filter(v => v !== value) : [...currentValue, value];
+        formControl.setValue(newValue);
+        super.handleChange();
+    }
+    handleMultipleDropdownChange(event) {
+        const formControl = this.form.get(this.controlName);
+        if (!formControl) {
+            return;
+        }
+        formControl.setValue(event);
+        super.handleChange();
+    }
+    isBooleanType(value) {
+        return Array.isArray(value) && value.length === 1 && value[0].min === 0 && value[0].max === 1;
+    }
+    getDisplayName() {
+        var _a, _b;
+        return ((((_a = this.section.model) === null || _a === void 0 ? void 0 : _a.properties) && this.section.model.properties['displayName']) || ((_b = this.section.model) === null || _b === void 0 ? void 0 : _b.type) || '');
+    }
+}
+VeloAttributeComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: VeloAttributeComponent, deps: [{ token: i1.FormScopeService }, { token: i2.SectionScopeService }], target: i0.ɵɵFactoryTarget.Component });
+VeloAttributeComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: VeloAttributeComponent, selector: "velo-attribute", usesInheritance: true, ngImport: i0, template: "<div class=\"form-group div-inline\" [formGroup]=\"form\">\n  <div class=\"input-form-input div-inline\" [class.input-form-input--required]=\"section.required\">\n    <label>\n      <ng-container *ngIf=\"section.required\"> * </ng-container>\n\n      {{ section.label }}\n    </label>\n    <div [ngSwitch]=\"section.controlType\" class=\"form-control-wrapper\">\n      <div *ngSwitchCase=\"'DROPDOWN'\">\n        <select\n          [id]=\"controlName\"\n          [formControlName]=\"controlName\"\n          class=\"form-control\"\n          (change)=\"handleChange()\"\n          [attr.disabled]=\"section.readOnly ? true : null\"\n        >\n          <option\n            *ngFor=\"let valueOption of getValueOptions(section.sectionValue?.valueOptions) || []\"\n            [ngValue]=\"valueOption\"\n          >\n            {{ getValueText(section.sectionValue?.valueOptions, valueOption) }}\n          </option>\n        </select>\n      </div>\n\n      <div *ngSwitchCase=\"'MULTISELECT'\">\n        <velo-multiselect\n          [id]=\"controlName\"\n          [formControlName]=\"controlName\"\n          [options]=\"getValueOptions(section.sectionValue?.valueOptions)\"\n          [attr.disabled]=\"section.readOnly ? true : null\"\n          (selectionChange)=\"handleMultipleDropdownChange($event)\"\n        ></velo-multiselect>\n      </div>\n\n      <div *ngSwitchCase=\"'RADIO'\">\n        <div\n          *ngFor=\"let valueOption of getValueOptions(section.sectionValue?.valueOptions)\"\n          class=\"radio-button\"\n          [attr.disabled]=\"section.readOnly ? true : null\"\n        >\n          <label>\n            <input\n              type=\"radio\"\n              [id]=\"controlName\"\n              [formControlName]=\"controlName\"\n              [value]=\"valueOption\"\n              (change)=\"handleChange()\"\n              [attr.disabled]=\"section.readOnly ? true : null\"\n            />\n            <i class=\"input-helper\"></i>\n            {{ getValueText(section.sectionValue?.valueOptions, valueOption) }}\n          </label>\n        </div>\n      </div>\n\n      <div *ngSwitchCase=\"'CHECKBOX'\">\n        <ng-container *ngIf=\"!isMultiselect; else multiselect\">\n          <div class=\"checkbox-select\" [attr.disabled]=\"section.readOnly ? true : null\">\n            <label>\n              <input\n                type=\"checkbox\"\n                [id]=\"controlName\"\n                [formControlName]=\"controlName\"\n                [checked]=\"section.sectionValue?.value === 1\"\n                (change)=\"handleChange()\"\n                [attr.disabled]=\"section.readOnly ? true : null\"\n              />\n\n              <i class=\"input-helper\"></i>\n              &nbsp;\n            </label>\n          </div>\n        </ng-container>\n\n        <ng-template #multiselect>\n          <div\n            *ngFor=\"let valueOption of getValueOptions(section.sectionValue?.valueOptions)\"\n            class=\"checkbox-select\"\n            [attr.disabled]=\"section.readOnly ? true : null\"\n          >\n            <label>\n              <input\n                type=\"checkbox\"\n                [id]=\"controlName\"\n                [checked]=\"section.sectionValue?.value.includes(valueOption)\"\n                (change)=\"handleMultiselectChange(valueOption)\"\n                [value]=\"valueOption\"\n                [attr.disabled]=\"section.readOnly ? true : null\"\n              />\n\n              <i class=\"input-helper\"></i>\n              {{ valueOption }}\n            </label>\n          </div>\n        </ng-template>\n      </div>\n\n      <div *ngSwitchCase=\"'DATE'\">\n        <input\n          type=\"text\"\n          class=\"form-control\"\n          [id]=\"controlName\"\n          [formControlName]=\"controlName\"\n          [attr.disabled]=\"section.readOnly ? true : null\"\n          (bsValueChange)=\"handleChangDate($event)\"\n          bsDatepicker\n        />\n      </div>\n\n      <div *ngSwitchDefault>\n        <input\n          type=\"text\"\n          class=\"form-control\"\n          [id]=\"controlName\"\n          [formControlName]=\"controlName\"\n          (blur)=\"form.controls[controlName].dirty && handleChange()\"\n          [attr.disabled]=\"section.readOnly ? true : null\"\n        />\n      </div>\n\n      <!-- Add validation messages -->\n      <!-- <div validation-messages [form]=\"form\" [controlId]=\"controlName\" [showForPristine]=\"true\"></div> -->\n    </div>\n  </div>\n</div>\n", components: [{ type: i3.MultiselectComponent, selector: "velo-multiselect", inputs: ["options"], outputs: ["selectionChange"] }], directives: [{ type: i4.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i4.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i5.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { type: i5.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { type: i4.SelectControlValueAccessor, selector: "select:not([multiple])[formControlName],select:not([multiple])[formControl],select:not([multiple])[ngModel]", inputs: ["compareWith"] }, { type: i4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i4.FormControlName, selector: "[formControlName]", inputs: ["disabled", "formControlName", "ngModel"], outputs: ["ngModelChange"] }, { type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i4.NgSelectOption, selector: "option", inputs: ["ngValue", "value"] }, { type: i4.ɵNgSelectMultipleOption, selector: "option", inputs: ["ngValue", "value"] }, { type: i4.RadioControlValueAccessor, selector: "input[type=radio][formControlName],input[type=radio][formControl],input[type=radio][ngModel]", inputs: ["name", "formControlName", "value"] }, { type: i4.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i4.CheckboxControlValueAccessor, selector: "input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]" }, { type: i5.NgSwitchDefault, selector: "[ngSwitchDefault]" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: VeloAttributeComponent, decorators: [{
+            type: Component,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/component-selector
+                    selector: 'velo-attribute',
+                    templateUrl: 'velo-attribute.component.html',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.FormScopeService }, { type: i2.SectionScopeService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"velo-attribute.component.js","sourceRoot":"","sources":["../../../../../../../../libs/sdk/runtime/execution/components/velo-attribute/velo-attribute.component.ts","../../../../../../../../libs/sdk/runtime/execution/components/velo-attribute/velo-attribute.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit } from '@angular/core';\nimport { FormScopeService } from '../../../services/form-scope.service';\nimport { SectionScopeService } from '../../../services/section-scope.service';\nimport { VeloAttributeDirective } from '../../directives/velo-attribute.directive';\n\n@Component({\n  // eslint-disable-next-line @angular-eslint/component-selector\n  selector: 'velo-attribute',\n  templateUrl: 'velo-attribute.component.html',\n})\nexport class VeloAttributeComponent extends VeloAttributeDirective implements OnInit {\n  controlName: string;\n  displayName: string;\n  isMultiselect: boolean;\n\n  constructor(formScope: FormScopeService, sectionScope: SectionScopeService) {\n    super(formScope, sectionScope);\n\n    this.controlName = this.section.id;\n    this.displayName = this.getDisplayName();\n    this.isMultiselect =\n      this.section.model?.attributes.find(attr => attr.name === this.section.boundData.entity.name)?.type ===\n      'MULTIPLE';\n  }\n\n  getValueOptions(valueOptions: unknown): (string | number)[] {\n    return this.isBooleanType(valueOptions) ? [0, 1] : (valueOptions as string[]);\n  }\n\n  getValueText(valueOptions: unknown, value: string | number): string {\n    if (this.isBooleanType(valueOptions)) {\n      return value === 0 ? 'False' : 'True';\n    }\n    return value as string;\n  }\n\n  handleMultiselectChange(value: string | number) {\n    const formControl = this.form.get(this.controlName);\n\n    if (!formControl) {\n      return;\n    }\n\n    const currentValue: (string | number)[] = formControl.value ?? [];\n    const newValue = currentValue.includes(value) ? currentValue.filter(v => v !== value) : [...currentValue, value];\n    formControl.setValue(newValue);\n\n    super.handleChange();\n  }\n\n  handleMultipleDropdownChange(event: any) {\n    const formControl = this.form.get(this.controlName);\n\n    if (!formControl) {\n      return;\n    }\n\n    formControl.setValue(event);\n    super.handleChange();\n  }\n\n  private isBooleanType(value: any): boolean {\n    return Array.isArray(value) && value.length === 1 && value[0].min === 0 && value[0].max === 1;\n  }\n\n  private getDisplayName(): string {\n    return (\n      (this.section.model?.properties && this.section.model.properties['displayName']) || this.section.model?.type || ''\n    );\n  }\n}\n","<div class=\"form-group div-inline\" [formGroup]=\"form\">\n  <div class=\"input-form-input div-inline\" [class.input-form-input--required]=\"section.required\">\n    <label>\n      <ng-container *ngIf=\"section.required\"> * </ng-container>\n\n      {{ section.label }}\n    </label>\n    <div [ngSwitch]=\"section.controlType\" class=\"form-control-wrapper\">\n      <div *ngSwitchCase=\"'DROPDOWN'\">\n        <select\n          [id]=\"controlName\"\n          [formControlName]=\"controlName\"\n          class=\"form-control\"\n          (change)=\"handleChange()\"\n          [attr.disabled]=\"section.readOnly ? true : null\"\n        >\n          <option\n            *ngFor=\"let valueOption of getValueOptions(section.sectionValue?.valueOptions) || []\"\n            [ngValue]=\"valueOption\"\n          >\n            {{ getValueText(section.sectionValue?.valueOptions, valueOption) }}\n          </option>\n        </select>\n      </div>\n\n      <div *ngSwitchCase=\"'MULTISELECT'\">\n        <velo-multiselect\n          [id]=\"controlName\"\n          [formControlName]=\"controlName\"\n          [options]=\"getValueOptions(section.sectionValue?.valueOptions)\"\n          [attr.disabled]=\"section.readOnly ? true : null\"\n          (selectionChange)=\"handleMultipleDropdownChange($event)\"\n        ></velo-multiselect>\n      </div>\n\n      <div *ngSwitchCase=\"'RADIO'\">\n        <div\n          *ngFor=\"let valueOption of getValueOptions(section.sectionValue?.valueOptions)\"\n          class=\"radio-button\"\n          [attr.disabled]=\"section.readOnly ? true : null\"\n        >\n          <label>\n            <input\n              type=\"radio\"\n              [id]=\"controlName\"\n              [formControlName]=\"controlName\"\n              [value]=\"valueOption\"\n              (change)=\"handleChange()\"\n              [attr.disabled]=\"section.readOnly ? true : null\"\n            />\n            <i class=\"input-helper\"></i>\n            {{ getValueText(section.sectionValue?.valueOptions, valueOption) }}\n          </label>\n        </div>\n      </div>\n\n      <div *ngSwitchCase=\"'CHECKBOX'\">\n        <ng-container *ngIf=\"!isMultiselect; else multiselect\">\n          <div class=\"checkbox-select\" [attr.disabled]=\"section.readOnly ? true : null\">\n            <label>\n              <input\n                type=\"checkbox\"\n                [id]=\"controlName\"\n                [formControlName]=\"controlName\"\n                [checked]=\"section.sectionValue?.value === 1\"\n                (change)=\"handleChange()\"\n                [attr.disabled]=\"section.readOnly ? true : null\"\n              />\n\n              <i class=\"input-helper\"></i>\n              &nbsp;\n            </label>\n          </div>\n        </ng-container>\n\n        <ng-template #multiselect>\n          <div\n            *ngFor=\"let valueOption of getValueOptions(section.sectionValue?.valueOptions)\"\n            class=\"checkbox-select\"\n            [attr.disabled]=\"section.readOnly ? true : null\"\n          >\n            <label>\n              <input\n                type=\"checkbox\"\n                [id]=\"controlName\"\n                [checked]=\"section.sectionValue?.value.includes(valueOption)\"\n                (change)=\"handleMultiselectChange(valueOption)\"\n                [value]=\"valueOption\"\n                [attr.disabled]=\"section.readOnly ? true : null\"\n              />\n\n              <i class=\"input-helper\"></i>\n              {{ valueOption }}\n            </label>\n          </div>\n        </ng-template>\n      </div>\n\n      <div *ngSwitchCase=\"'DATE'\">\n        <input\n          type=\"text\"\n          class=\"form-control\"\n          [id]=\"controlName\"\n          [formControlName]=\"controlName\"\n          [attr.disabled]=\"section.readOnly ? true : null\"\n          (bsValueChange)=\"handleChangDate($event)\"\n          bsDatepicker\n        />\n      </div>\n\n      <div *ngSwitchDefault>\n        <input\n          type=\"text\"\n          class=\"form-control\"\n          [id]=\"controlName\"\n          [formControlName]=\"controlName\"\n          (blur)=\"form.controls[controlName].dirty && handleChange()\"\n          [attr.disabled]=\"section.readOnly ? true : null\"\n        />\n      </div>\n\n      <!-- Add validation messages -->\n      <!-- <div validation-messages [form]=\"form\" [controlId]=\"controlName\" [showForPristine]=\"true\"></div> -->\n    </div>\n  </div>\n</div>\n"]}