@veloceapps/sdk 7.0.0-9 → 7.0.1-0

package/esm2020/runtime/components/ui-runtime-preview/runtime-preview.component.mjs

@@ -0,0 +1,108 @@
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { ConfigurationApiService } from '@veloceapps/api';
+import { ConfigurationContextMode, EntityUtil, RuntimeModel, SectionPathUtil, } from '@veloceapps/core';
+import { ContextService, RuntimeMode } from '@veloceapps/sdk/core';
+import { combineLatest, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { ProductModelCacheService } from '../../services/product-model-cache.service';
+import { RuntimeService } from '../../services/runtime.service';
+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 {
+    set uiDefinition(value) {
+        this._uiDefinition = value;
+        this.initDefinition(value);
+    }
+    constructor(runtimeService, modelCacheService, configurationApiService, contextService) {
+        this.runtimeService = runtimeService;
+        this.modelCacheService = modelCacheService;
+        this.configurationApiService = configurationApiService;
+        this.contextService = contextService;
+        this.destroy$ = new Subject();
+    }
+    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) => {
+                return {
+                    ...trunk,
+                    [variable.name]: initialisedUiDefinition.externals?.[variable.name] ?? '',
+                };
+            }, {});
+        }
+        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]) => {
+            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?.typeName) {
+                uiDefinition.rootType = rootType.typeName;
+            }
+            const contextProductId = rootType ? rootType.productId : undefined;
+            const context = {
+                modelId: this.modelId ?? '',
+                uiDefinition: uiDefinition,
+                runtimeModel,
+                runtimeMode: RuntimeMode.TEST,
+                productId: contextProductId,
+                properties: uiDefinition.externals,
+            };
+            this.runtimeService.startRuntime(context, {});
+        });
+    }
+}
+RuntimePreviewComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", 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: "14.0.0", version: "15.2.8", 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"], dependencies: [{ kind: "component", type: i5.RuntimeComponent, selector: "vl-runtime", outputs: ["solutionUpdated"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: RuntimePreviewComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'vl-runtime-preview', changeDetection: ChangeDetectionStrategy.OnPush, template: "<vl-runtime (solutionUpdated)=\"onSolutionUpdated($event)\"></vl-runtime>\n", styles: [":host{flex-grow:1}\n"] }]
+        }], 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() public modelId?: string;\n  @Input() public 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(): void {\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/esm2020/runtime/execution/components/children-placeholder/children-placeholder.component.mjs

@@ -0,0 +1,60 @@
+import { Component, Input } from '@angular/core';
+import { OrderByPipe } from '@veloceapps/core';
+import { CollapsibleStateService } from '../../../services/collapsible-state.service';
+import { FormScopeService } from '../../../services/form-scope.service';
+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/form-scope.service";
+import * as i3 from "../../../services/collapsible-state.service";
+import * as i4 from "@angular/common";
+import * as i5 from "../execution-section-renderer/execution-section-renderer.component";
+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 => {
+            const lineItemId = e[0];
+            if (this.section.model?.id === lineItemId) {
+                this.collapsed = e[1];
+            }
+        });
+        this.setChildren();
+    }
+    ngOnChanges(changes) {
+        if (!this.children || changes['children']?.currentValue !== changes['children']?.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: "15.2.8", ngImport: i0, type: ChildrenPlaceholderComponent, deps: [{ token: i1.SectionScopeService }, { token: i2.FormScopeService }, { token: i3.CollapsibleStateService }], target: i0.ɵɵFactoryTarget.Component });
+ChildrenPlaceholderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.8", 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", dependencies: [{ kind: "directive", type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i5.ExecutionSectionRendererComponent, selector: "section-renderer", inputs: ["section", "form"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ChildrenPlaceholderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'children-placeholder', providers: [OrderByPipe], 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" }]
+        }], 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: "15.2.8", ngImport: i0, type: TemplateComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+TemplateComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.8", 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", dependencies: [{ kind: "directive", type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i5.ExecutionSectionRendererComponent, selector: "section-renderer", inputs: ["section", "form"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: TemplateComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'template-component', 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" }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hpbGRyZW4tcGxhY2Vob2xkZXIuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9zZGsvcnVudGltZS9leGVjdXRpb24vY29tcG9uZW50cy9jaGlsZHJlbi1wbGFjZWhvbGRlci9jaGlsZHJlbi1wbGFjZWhvbGRlci5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3Nkay9ydW50aW1lL2V4ZWN1dGlvbi9jb21wb25lbnRzL2NoaWxkcmVuLXBsYWNlaG9sZGVyL2NoaWxkcmVuLXBsYWNlaG9sZGVyLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUErQyxNQUFNLGVBQWUsQ0FBQztBQUU5RixPQUFPLEVBQUUsV0FBVyxFQUFXLE1BQU0sa0JBQWtCLENBQUM7QUFFeEQsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sNkNBQTZDLENBQUM7QUFDdEYsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sc0NBQXNDLENBQUM7QUFDeEUsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0seUNBQXlDLENBQUM7Ozs7Ozs7QUFROUUsTUFBTSxPQUFPLDRCQUE0QjtJQWN2QyxZQUNVLFlBQWlDLEVBQ2pDLFNBQTJCLEVBQzNCLGdCQUF5QztRQUZ6QyxpQkFBWSxHQUFaLFlBQVksQ0FBcUI7UUFDakMsY0FBUyxHQUFULFNBQVMsQ0FBa0I7UUFDM0IscUJBQWdCLEdBQWhCLGdCQUFnQixDQUF5QjtRQWI1QyxjQUFTLEdBQWMsRUFBRSxDQUFDO1FBUTFCLGNBQVMsR0FBRyxLQUFLLENBQUM7SUFNdEIsQ0FBQztJQUVHLFFBQVE7UUFDYixJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksQ0FBQyxZQUFZLENBQUMsT0FBTyxDQUFDO1FBQ3pDLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUM7UUFFaEMsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLGdCQUFnQixDQUFDLGtCQUFrQixDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7UUFFN0csSUFBSSxDQUFDLEdBQUcsR0FBRyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsb0JBQW9CLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxFQUFFO1lBQ2xFLE1BQU0sVUFBVSxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUV4QixJQUFJLElBQUksQ0FBQyxPQUFPLENBQUMsS0FBSyxFQUFFLEVBQUUsS0FBSyxVQUFVLEVBQUU7Z0JBQ3pDLElBQUksQ0FBQyxTQUFTLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO2FBQ3ZCO1FBQ0gsQ0FBQyxDQUFDLENBQUM7UUFFSCxJQUFJLENBQUMsV0FBVyxFQUFFLENBQUM7SUFDckIsQ0FBQztJQUVNLFdBQVcsQ0FBQyxPQUFzQjtRQUN2QyxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsSUFBSSxPQUFPLENBQUMsVUFBVSxDQUFDLEVBQUUsWUFBWSxLQUFLLE9BQU8sQ0FBQyxVQUFVLENBQUMsRUFBRSxhQUFhLEVBQUU7WUFDOUYsSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDO1NBQ3BCO0lBQ0gsQ0FBQztJQUVNLFdBQVc7UUFDaEIsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQztJQUN6RSxDQUFDO0lBRU0sV0FBVztRQUNoQixJQUFJLENBQUMsR0FBRyxDQUFDLFdBQVcsRUFBRSxDQUFDO0lBQ3pCLENBQUM7O3lIQWpEVSw0QkFBNEI7NkdBQTVCLDRCQUE0QixpRkFGNUIsQ0FBQyxXQUFXLENBQUMsK0NDWjFCLHNPQUtBOzJGRFNhLDRCQUE0QjtrQkFOeEMsU0FBUzsrQkFFRSxzQkFBc0IsYUFFckIsQ0FBQyxXQUFXLENBQUM7K0tBSWpCLFFBQVE7c0JBRGQsS0FBSzs7QUF3RFIsTUFBTSxPQUFPLGlCQUFrQixTQUFRLDRCQUE0Qjs7OEdBQXRELGlCQUFpQjtrR0FBakIsaUJBQWlCLGlGQ3ZFOUIsc09BS0E7MkZEa0VhLGlCQUFpQjtrQkFMN0IsU0FBUzsrQkFFRSxvQkFBb0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIElucHV0LCBPbkNoYW5nZXMsIE9uRGVzdHJveSwgT25Jbml0LCBTaW1wbGVDaGFuZ2VzIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBGb3JtR3JvdXAgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5pbXBvcnQgeyBPcmRlckJ5UGlwZSwgU2VjdGlvbiB9IGZyb20gJ0B2ZWxvY2VhcHBzL2NvcmUnO1xuaW1wb3J0IHsgU3Vic2NyaXB0aW9uIH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBDb2xsYXBzaWJsZVN0YXRlU2VydmljZSB9IGZyb20gJy4uLy4uLy4uL3NlcnZpY2VzL2NvbGxhcHNpYmxlLXN0YXRlLnNlcnZpY2UnO1xuaW1wb3J0IHsgRm9ybVNjb3BlU2VydmljZSB9IGZyb20gJy4uLy4uLy4uL3NlcnZpY2VzL2Zvcm0tc2NvcGUuc2VydmljZSc7XG5pbXBvcnQgeyBTZWN0aW9uU2NvcGVTZXJ2aWNlIH0gZnJvbSAnLi4vLi4vLi4vc2VydmljZXMvc2VjdGlvbi1zY29wZS5zZXJ2aWNlJztcblxuQENvbXBvbmVudCh7XG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAYW5ndWxhci1lc2xpbnQvY29tcG9uZW50LXNlbGVjdG9yXG4gIHNlbGVjdG9yOiAnY2hpbGRyZW4tcGxhY2Vob2xkZXInLFxuICB0ZW1wbGF0ZVVybDogJ2NoaWxkcmVuLXBsYWNlaG9sZGVyLmNvbXBvbmVudC5odG1sJyxcbiAgcHJvdmlkZXJzOiBbT3JkZXJCeVBpcGVdLFxufSlcbmV4cG9ydCBjbGFzcyBDaGlsZHJlblBsYWNlaG9sZGVyQ29tcG9uZW50IGltcGxlbWVudHMgT25Jbml0LCBPbkNoYW5nZXMsIE9uRGVzdHJveSB7XG4gIEBJbnB1dCgpXG4gIHB1YmxpYyBjaGlsZHJlbj86IFNlY3Rpb25bXTtcblxuICBwdWJsaWMgX2NoaWxkcmVuOiBTZWN0aW9uW10gPSBbXTtcblxuICBwdWJsaWMgc2VjdGlvbiE6IFNlY3Rpb247XG5cbiAgcHVibGljIGZvcm0hOiBGb3JtR3JvdXA7XG5cbiAgcHVibGljIHN1YiE6IFN1YnNjcmlwdGlvbjtcblxuICBwdWJsaWMgY29sbGFwc2VkID0gZmFsc2U7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcHJpdmF0ZSBzZWN0aW9uU2NvcGU6IFNlY3Rpb25TY29wZVNlcnZpY2UsXG4gICAgcHJpdmF0ZSBmb3JtU2NvcGU6IEZvcm1TY29wZVNlcnZpY2UsXG4gICAgcHJpdmF0ZSBjb2xsYXBzaWJsZVN0YXRlOiBDb2xsYXBzaWJsZVN0YXRlU2VydmljZSxcbiAgKSB7fVxuXG4gIHB1YmxpYyBuZ09uSW5pdCgpOiB2b2lkIHtcbiAgICB0aGlzLnNlY3Rpb24gPSB0aGlzLnNlY3Rpb25TY29wZS5zZWN0aW9uO1xuICAgIHRoaXMuZm9ybSA9IHRoaXMuZm9ybVNjb3BlLmZvcm07XG5cbiAgICB0aGlzLmNvbGxhcHNlZCA9IHRoaXMuc2VjdGlvbi5tb2RlbCA/IHRoaXMuY29sbGFwc2libGVTdGF0ZS5pc0NvbGxhcHNlZFNlY3Rpb24odGhpcy5zZWN0aW9uLm1vZGVsLmlkKSA6IHRydWU7XG5cbiAgICB0aGlzLnN1YiA9IHRoaXMuY29sbGFwc2libGVTdGF0ZS5jb2xsYXBzZVNlY3Rpb25FdmVudC5zdWJzY3JpYmUoZSA9PiB7XG4gICAgICBjb25zdCBsaW5lSXRlbUlkID0gZVswXTtcblxuICAgICAgaWYgKHRoaXMuc2VjdGlvbi5tb2RlbD8uaWQgPT09IGxpbmVJdGVtSWQpIHtcbiAgICAgICAgdGhpcy5jb2xsYXBzZWQgPSBlWzFdO1xuICAgICAgfVxuICAgIH0pO1xuXG4gICAgdGhpcy5zZXRDaGlsZHJlbigpO1xuICB9XG5cbiAgcHVibGljIG5nT25DaGFuZ2VzKGNoYW5nZXM6IFNpbXBsZUNoYW5nZXMpOiB2b2lkIHtcbiAgICBpZiAoIXRoaXMuY2hpbGRyZW4gfHwgY2hhbmdlc1snY2hpbGRyZW4nXT8uY3VycmVudFZhbHVlICE9PSBjaGFuZ2VzWydjaGlsZHJlbiddPy5wcmV2aW91c1ZhbHVlKSB7XG4gICAgICB0aGlzLnNldENoaWxkcmVuKCk7XG4gICAgfVxuICB9XG5cbiAgcHVibGljIHNldENoaWxkcmVuKCk6IHZvaWQge1xuICAgIHRoaXMuX2NoaWxkcmVuID0gdGhpcy5jaGlsZHJlbiA/IHRoaXMuY2hpbGRyZW4gOiB0aGlzLnNlY3Rpb24uY2hpbGRyZW47XG4gIH1cblxuICBwdWJsaWMgbmdPbkRlc3Ryb3koKTogdm9pZCB7XG4gICAgdGhpcy5zdWIudW5zdWJzY3JpYmUoKTtcbiAgfVxufVxuXG5AQ29tcG9uZW50KHtcbiAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEBhbmd1bGFyLWVzbGludC9jb21wb25lbnQtc2VsZWN0b3JcbiAgc2VsZWN0b3I6ICd0ZW1wbGF0ZS1jb21wb25lbnQnLFxuICB0ZW1wbGF0ZVVybDogJ2NoaWxkcmVuLXBsYWNlaG9sZGVyLmNvbXBvbmVudC5odG1sJyxcbn0pXG5leHBvcnQgY2xhc3MgVGVtcGxhdGVDb21wb25lbnQgZXh0ZW5kcyBDaGlsZHJlblBsYWNlaG9sZGVyQ29tcG9uZW50IHt9XG4iLCI8bmctY29udGFpbmVyICpuZ0lmPVwiIWNvbGxhcHNlZFwiPlxuICA8bmctY29udGFpbmVyICpuZ0Zvcj1cImxldCBjaGlsZCBvZiBfY2hpbGRyZW5cIj5cbiAgICA8c2VjdGlvbi1yZW5kZXJlciBbc2VjdGlvbl09XCJjaGlsZFwiIFtmb3JtXT1cImZvcm1cIiAqbmdJZj1cIiFjaGlsZC5oaWRkZW5cIj48L3NlY3Rpb24tcmVuZGVyZXI+XG4gIDwvbmctY29udGFpbmVyPlxuPC9uZy1jb250YWluZXI+XG4iXX0=

package/esm2020/runtime/execution/components/context-provider/context-provider.component.mjs

@@ -0,0 +1,39 @@
+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({
+            ...context,
+            runtimeModel: RuntimeModel.create(this.types, this.products),
+        });
+    }
+}
+ContextProviderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ContextProviderComponent, deps: [{ token: RuntimeService }], target: i0.ɵɵFactoryTarget.Component });
+ContextProviderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.8", type: ContextProviderComponent, selector: "vl-context-provider", inputs: { types: "types", products: "products" }, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", 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/esm2020/runtime/execution/components/execution-section-renderer/execution-section-renderer.component.mjs

@@ -0,0 +1,67 @@
+import { Component, Injector, Input, NgModuleRef, ViewChild, ViewContainerRef, } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { Section } from '@veloceapps/core';
+import { SectionScopeService } from '../../../services/section-scope.service';
+import { SectionStoreService } from '../../../services/section-store.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 {
+    set section(value) {
+        this._section = value;
+        this.sectionScope.section = value;
+    }
+    get section() {
+        return this._section;
+    }
+    constructor(_injector, _m, sectionScope, sectionStore) {
+        this._injector = _injector;
+        this._m = _m;
+        this.sectionScope = sectionScope;
+        this.sectionStore = sectionStore;
+        this.componentRef = null;
+    }
+    ngOnInit() {
+        this.renderSection();
+    }
+    ngAfterViewInit() {
+        if (this.componentRef) {
+            this.sectionScope.templates.next(this.componentRef.instance['templates']?.toArray() ?? []);
+        }
+    }
+    ngOnDestroy() {
+        if (this.componentRef) {
+            this.componentRef.destroy();
+            this.componentRef = null;
+        }
+    }
+    renderSection() {
+        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', `${this._section.model?.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: "15.2.8", 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: "14.0.0", version: "15.2.8", 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: "15.2.8", ngImport: i0, type: ExecutionSectionRendererComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'section-renderer', providers: [SectionScopeService], template: "<ng-template #container></ng-template>", styles: [":host{display:contents}\n"] }]
+        }], 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,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

package/esm2020/runtime/execution/components/federated/federated.component.mjs

@@ -0,0 +1,74 @@
+import { ApplicationRef, ChangeDetectionStrategy, Compiler, Component, ElementRef, EventEmitter, Injector, Input, Output, Renderer2, 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 => {
+                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(this.moduleHostRef?.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: "15.2.8", 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: "14.0.0", version: "15.2.8", 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: "15.2.8", ngImport: i0, type: FederatedComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'veloce-host-federated', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div #moduleHost></div>\n", styles: [":host{display:block}div{height:100%}\n"] }]
+        }], 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/esm2020/runtime/execution/components/velo-attribute/velo-attribute.component.mjs

@@ -0,0 +1,60 @@
+import { Component } from '@angular/core';
+import { FormScopeService } from '../../../services/form-scope.service';
+import { SectionScopeService } from '../../../services/section-scope.service';
+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 "@angular/common";
+import * as i4 from "@angular/forms";
+import * as i5 from "../velo-multiselect/velo-multiselect.component";
+export class VeloAttributeComponent extends VeloAttributeDirective {
+    constructor(formScope, sectionScope) {
+        super(formScope, sectionScope);
+        this.controlName = this.section.id;
+        this.displayName = this.getDisplayName();
+        this.isMultiselect =
+            this.section.model?.attributes.find(attr => attr.name === this.section.boundData.entity.name)?.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) {
+        const formControl = this.form.get(this.controlName);
+        if (!formControl) {
+            return;
+        }
+        const currentValue = formControl.value ?? [];
+        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() {
+        return ((this.section.model?.properties && this.section.model.properties['displayName']) || this.section.model?.type || '');
+    }
+}
+VeloAttributeComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: VeloAttributeComponent, deps: [{ token: i1.FormScopeService }, { token: i2.SectionScopeService }], target: i0.ɵɵFactoryTarget.Component });
+VeloAttributeComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.8", 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", dependencies: [{ kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { kind: "directive", type: i3.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { kind: "directive", type: i3.NgSwitchDefault, selector: "[ngSwitchDefault]" }, { kind: "directive", type: i4.NgSelectOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i4.ɵNgSelectMultipleOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", 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]" }, { kind: "directive", type: i4.CheckboxControlValueAccessor, selector: "input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]" }, { kind: "directive", type: i4.SelectControlValueAccessor, selector: "select:not([multiple])[formControlName],select:not([multiple])[formControl],select:not([multiple])[ngModel]", inputs: ["compareWith"] }, { kind: "directive", type: i4.RadioControlValueAccessor, selector: "input[type=radio][formControlName],input[type=radio][formControl],input[type=radio][ngModel]", inputs: ["name", "formControlName", "value"] }, { kind: "directive", type: i4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i4.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i4.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i4.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "component", type: i5.MultiselectComponent, selector: "velo-multiselect", inputs: ["options"], outputs: ["selectionChange"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: VeloAttributeComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'velo-attribute', 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" }]
+        }], 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  public controlName: string;\n  public displayName: string;\n  public 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  public getValueOptions(valueOptions: unknown): (string | number)[] {\n    return this.isBooleanType(valueOptions) ? [0, 1] : (valueOptions as string[]);\n  }\n\n  public 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  public handleMultiselectChange(value: string | number): void {\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  public handleMultipleDropdownChange(event: any): void {\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"]}