@veloceapps/sdk 7.0.0-9 → 7.0.1-0

package/esm2020/runtime/execution/directives/velo-port.directive.mjs

@@ -0,0 +1,376 @@
+import { Component, Directive } from '@angular/core';
+import { EntityUtil } from '@veloceapps/core';
+import { take } from 'rxjs/operators';
+import { ConfigurationService } from '../../services/configuration.service';
+import { FormScopeService } from '../../services/form-scope.service';
+import { SectionHelperService } from '../../services/section-helper.service';
+import { SectionScopeService } from '../../services/section-scope.service';
+import { SectionsBinderHelper } from '../../utils/sections-binder.helper';
+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 "../../services/configuration.service";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/forms";
+import * as i6 from "@veloceapps/core";
+export class SectionContextAware {
+    constructor(formScope, sectionScope) {
+        this.formScope = formScope;
+        this.sectionScope = sectionScope;
+    }
+    ngOnInit() {
+        this.form = this.formScope.form;
+        this.section = this.sectionScope.section;
+        this.initControlNames();
+    }
+    initControlNames() {
+        this.controlName = this.section.id;
+        this.qtyControlName = this.section.id + 'qty';
+    }
+    //TODO ALE CONSIDER STORE INSTEAD OF CALCULATE EVERY TIME
+    isAddAllowed(quantityToAdd = 1) {
+        return this.section.model
+            ? SectionsBinderHelper.isAddAllowed(this.section.model, this.section.boundData.name, quantityToAdd)
+            : false;
+    }
+    isRemoveAllowed(quantityToRemove = 1) {
+        return this.section.model
+            ? SectionsBinderHelper.isRemoveAllowed(this.section.model, this.section.boundData.name, quantityToRemove)
+            : false;
+    }
+    handleCreate(valueOption) {
+        if (!this.isAddAllowed()) {
+            return;
+        }
+        const updateData = {
+            id: this.section.id,
+            action: 'create',
+            valueOption: EntityUtil.isPresent(valueOption) ? valueOption : void 0,
+        };
+        this.formScope.publishFormUpdate(updateData);
+    }
+    handleChange(valueOption) {
+        const updateData = {
+            id: this.section.id,
+            action: 'update',
+            valueOption: EntityUtil.isPresent(valueOption) ? valueOption : void 0,
+        };
+        this.formScope.publishFormUpdate(updateData);
+    }
+    handleQtyChange(valueOption) {
+        const updateData = {
+            id: this.section.id,
+            action: 'qtyUpdate',
+            valueOption: valueOption,
+        };
+        this.formScope.publishFormUpdate(updateData);
+    }
+    handleRemove(valueOption) {
+        const updateData = {
+            id: this.section.id,
+            action: 'remove',
+            valueOption: valueOption,
+        };
+        this.formScope.publishFormUpdate(updateData);
+    }
+    handleCopy(valueOption) {
+        const updateData = {
+            id: this.section.id,
+            action: 'copy',
+            valueOption: valueOption,
+        };
+        this.formScope.publishFormUpdate(updateData);
+    }
+}
+SectionContextAware.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: SectionContextAware, deps: [{ token: i1.FormScopeService }, { token: i2.SectionScopeService }], target: i0.ɵɵFactoryTarget.Directive });
+SectionContextAware.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.8", type: SectionContextAware, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: SectionContextAware, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.FormScopeService }, { type: i2.SectionScopeService }]; } });
+export class LineItemDirective {
+    constructor(formScope, sectionScope, configurationService) {
+        this.formScope = formScope;
+        this.sectionScope = sectionScope;
+        this.configurationService = configurationService;
+    }
+    ngOnInit() {
+        this.section = this.sectionScope.section;
+        this.lineItem = this.section.model;
+    }
+    handlePatch(rootLineItem) {
+        const updateData = {
+            id: this.sectionScope.section.id,
+            action: 'patch',
+            valueOption: rootLineItem,
+        };
+        this.formScope.publishFormUpdate(updateData);
+    }
+    configure(runtimeContext, configurableRamp) {
+        return this.configurationService
+            .configure(runtimeContext, { configurableRamp })
+            .pipe(take(1))
+            .toPromise();
+    }
+}
+LineItemDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: LineItemDirective, deps: [{ token: i1.FormScopeService }, { token: i2.SectionScopeService }, { token: i3.ConfigurationService }], target: i0.ɵɵFactoryTarget.Directive });
+LineItemDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.8", type: LineItemDirective, selector: "line-item", exportAs: ["liApi"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: LineItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: 'line-item',
+                    exportAs: 'liApi',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.FormScopeService }, { type: i2.SectionScopeService }, { type: i3.ConfigurationService }]; } });
+export class VeloPortDirective extends SectionContextAware {
+    constructor(formScope, sectionScope) {
+        super(formScope, sectionScope);
+        this.valueQuantities = {};
+    }
+    handlePriceAdjustment(action, valueOption, amount) {
+        const updateData = {
+            id: this.section.id,
+            action,
+            valueOption,
+            options: { amount },
+        };
+        this.formScope.publishFormUpdate(updateData);
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.initQuantity();
+    }
+    handleUpsert(valueOption, event) {
+        if (EntityUtil.isPresent(this.valueQuantities[valueOption]) && EntityUtil.isPresent(event)) {
+            event?.preventDefault();
+            return;
+        }
+        else if (Object.keys(this.valueQuantities).length > 0) {
+            this.handleChange(valueOption);
+        }
+        else {
+            this.handleCreate(valueOption);
+        }
+    }
+    isActive(valueOption) {
+        return EntityUtil.isPresent(this.valueQuantities[valueOption]);
+    }
+    initQuantity() {
+        this.valueQuantities = this.section.model
+            ? SectionsBinderHelper.getQuantityGroupByValue(this.section.model, this.section.boundData.name)
+            : {};
+    }
+    //Quantity Stepper Functions
+    handleNextVal(valueOption) {
+        let initQty = this.valueQuantities[valueOption] || 0;
+        if (this.isAddAllowed()) {
+            if (initQty > 0) {
+                const typeSection = SectionHelperService.findSectionForValue(this.section, valueOption);
+                if (typeSection) {
+                    this.form.controls[typeSection.id + 'qty'].setValue(++initQty);
+                    this.handleQtyChange(valueOption);
+                }
+            }
+            else {
+                this.handleCreate(valueOption);
+            }
+        }
+    }
+    handlePrevVal(valueOption) {
+        let initQty = this.valueQuantities[valueOption] || 0;
+        if (this.isRemoveAllowed()) {
+            if (initQty < 2) {
+                this.handleRemove(valueOption);
+            }
+            else {
+                const typeSection = SectionHelperService.findSectionForValue(this.section, valueOption);
+                if (typeSection) {
+                    this.form.controls[typeSection.id + 'qty'].setValue(--initQty);
+                    this.handleQtyChange(valueOption);
+                }
+            }
+        }
+    }
+    handleManualQtyChange(valueOption, qtyVal) {
+        const initQty = this.valueQuantities[valueOption] || 0;
+        if (isNaN(+qtyVal) || +qtyVal < 0 || initQty === +qtyVal) {
+            return;
+        }
+        const newQty = +qtyVal;
+        if (initQty === 0) {
+            if (this.isAddAllowed(newQty)) {
+                this.form.controls[this.qtyControlName].setValue(newQty);
+                this.handleCreate(valueOption);
+            }
+        }
+        else if (newQty === 0) {
+            if (this.isRemoveAllowed()) {
+                this.handleRemove(valueOption);
+            }
+        }
+        else {
+            const typeSection = SectionHelperService.findSectionForValue(this.section, valueOption);
+            if (typeSection) {
+                const dif = newQty - initQty;
+                const isAllowed = dif > 0 ? this.isAddAllowed(dif) : this.isRemoveAllowed(dif * -1);
+                if (isAllowed) {
+                    this.form.controls[typeSection.id + 'qty'].setValue(newQty);
+                    this.handleQtyChange(valueOption);
+                }
+            }
+        }
+    }
+    handleNetPriceAdjustment(valueOption, amount) {
+        this.handlePriceAdjustment('adjustNetPrice', valueOption, amount);
+    }
+    handleListPriceAdjustment(valueOption, amount) {
+        this.handlePriceAdjustment('adjustListPrice', valueOption, amount);
+    }
+}
+VeloPortDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: VeloPortDirective, deps: [{ token: i1.FormScopeService }, { token: i2.SectionScopeService }], target: i0.ɵɵFactoryTarget.Directive });
+VeloPortDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.8", type: VeloPortDirective, selector: "velo-port", exportAs: ["portApi"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: VeloPortDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: 'velo-port',
+                    exportAs: 'portApi',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.FormScopeService }, { type: i2.SectionScopeService }]; } });
+export class VeloDropdownComponent extends SectionContextAware {
+    constructor(formScope, sectionScope) {
+        super(formScope, sectionScope);
+    }
+}
+VeloDropdownComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: VeloDropdownComponent, deps: [{ token: i1.FormScopeService }, { token: i2.SectionScopeService }], target: i0.ɵɵFactoryTarget.Component });
+VeloDropdownComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.8", type: VeloDropdownComponent, selector: "velo-dropdown", usesInheritance: true, ngImport: i0, template: `
+    <div class="input-form-input div-inline" [formGroup]="form">
+      <label [for]="controlName">{{ section.label }}</label>
+      <div class="form-control-wrapper">
+        <select [id]="controlName" [formControlName]="controlName" class="form-control">
+          <option *ngFor="let valueOption of section.sectionValue?.valueOptions" [ngValue]="valueOption">
+            {{ section.sectionValue?.displayValues?.[valueOption] || valueOption }}
+          </option>
+        </select>
+      </div>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "directive", type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i5.NgSelectOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i5.ɵNgSelectMultipleOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i5.SelectControlValueAccessor, selector: "select:not([multiple])[formControlName],select:not([multiple])[formControl],select:not([multiple])[ngModel]", inputs: ["compareWith"] }, { kind: "directive", type: i5.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i5.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i5.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i5.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: VeloDropdownComponent, decorators: [{
+            type: Component,
+            args: [{
+                    // moduleId: module.id,
+                    // eslint-disable-next-line @angular-eslint/component-selector
+                    selector: 'velo-dropdown',
+                    template: `
+    <div class="input-form-input div-inline" [formGroup]="form">
+      <label [for]="controlName">{{ section.label }}</label>
+      <div class="form-control-wrapper">
+        <select [id]="controlName" [formControlName]="controlName" class="form-control">
+          <option *ngFor="let valueOption of section.sectionValue?.valueOptions" [ngValue]="valueOption">
+            {{ section.sectionValue?.displayValues?.[valueOption] || valueOption }}
+          </option>
+        </select>
+      </div>
+    </div>
+  `,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.FormScopeService }, { type: i2.SectionScopeService }]; } });
+export class VeloQuantityComponent extends SectionContextAware {
+    constructor(formScope, sectionScope) {
+        super(formScope, sectionScope);
+    }
+}
+VeloQuantityComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: VeloQuantityComponent, deps: [{ token: i1.FormScopeService }, { token: i2.SectionScopeService }], target: i0.ɵɵFactoryTarget.Component });
+VeloQuantityComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.8", type: VeloQuantityComponent, selector: "velo-quantity", usesInheritance: true, ngImport: i0, template: `
+    <div class="input-form-input div-inline quantity-form-input" [formGroup]="form">
+      <label [for]="qtyControlName"> Quantity </label>
+      <div class="form-control-wrapper">
+        <input
+          [id]="controlName"
+          [formControlName]="qtyControlName"
+          [attr.disabled]="isAddAllowed() === true ? null : true"
+          type="text"
+          class="form-control"
+          size="3"
+        />
+
+        <div
+          class="validation-message"
+          [hidden]="form.controls[qtyControlName].valid || form.controls[qtyControlName].pristine"
+        >
+          <div *ngFor="let key of form.controls[qtyControlName].errors | values">
+            <span> {{ form.controls[qtyControlName].errors?.[key].message }}</span>
+          </div>
+        </div>
+      </div>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "directive", type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i5.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: i5.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i5.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i5.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i5.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "pipe", type: i6.ValuesPipe, name: "values" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: VeloQuantityComponent, decorators: [{
+            type: Component,
+            args: [{
+                    // moduleId: module.id,
+                    // eslint-disable-next-line @angular-eslint/component-selector
+                    selector: 'velo-quantity',
+                    template: `
+    <div class="input-form-input div-inline quantity-form-input" [formGroup]="form">
+      <label [for]="qtyControlName"> Quantity </label>
+      <div class="form-control-wrapper">
+        <input
+          [id]="controlName"
+          [formControlName]="qtyControlName"
+          [attr.disabled]="isAddAllowed() === true ? null : true"
+          type="text"
+          class="form-control"
+          size="3"
+        />
+
+        <div
+          class="validation-message"
+          [hidden]="form.controls[qtyControlName].valid || form.controls[qtyControlName].pristine"
+        >
+          <div *ngFor="let key of form.controls[qtyControlName].errors | values">
+            <span> {{ form.controls[qtyControlName].errors?.[key].message }}</span>
+          </div>
+        </div>
+      </div>
+    </div>
+  `,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.FormScopeService }, { type: i2.SectionScopeService }]; } });
+export class VeloQuantityButtonComponent extends SectionContextAware {
+    constructor(formScope, sectionScope) {
+        super(formScope, sectionScope);
+    }
+}
+VeloQuantityButtonComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: VeloQuantityButtonComponent, deps: [{ token: i1.FormScopeService }, { token: i2.SectionScopeService }], target: i0.ɵɵFactoryTarget.Component });
+VeloQuantityButtonComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.8", type: VeloQuantityButtonComponent, selector: "velo-quantity-button", usesInheritance: true, ngImport: i0, template: `
+    <div class="input-form-input div-inline quantity-form-input">
+      <div class="form-control-wrapper">
+        <a href="javascript:void(0);" (click)="handleCreate()">
+          <div class="add-config-control" [attr.disabled]="isAddAllowed() === true ? null : true">
+            <i class="fa fa-plus plus-icon"></i>
+          </div>
+        </a>
+      </div>
+    </div>
+  `, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: VeloQuantityButtonComponent, decorators: [{
+            type: Component,
+            args: [{
+                    // moduleId: module.id,
+                    // eslint-disable-next-line @angular-eslint/component-selector
+                    selector: 'velo-quantity-button',
+                    template: `
+    <div class="input-form-input div-inline quantity-form-input">
+      <div class="form-control-wrapper">
+        <a href="javascript:void(0);" (click)="handleCreate()">
+          <div class="add-config-control" [attr.disabled]="isAddAllowed() === true ? null : true">
+            <i class="fa fa-plus plus-icon"></i>
+          </div>
+        </a>
+      </div>
+    </div>
+  `,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.FormScopeService }, { type: i2.SectionScopeService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"velo-port.directive.js","sourceRoot":"","sources":["../../../../../../../libs/sdk/runtime/execution/directives/velo-port.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Directive, OnInit } from '@angular/core';\nimport { FormGroup } from '@angular/forms';\nimport { EntityUtil, LineItem, Section } from '@veloceapps/core';\nimport { take } from 'rxjs/operators';\nimport { ConfigurationService } from '../../services/configuration.service';\nimport { FormScopeService } from '../../services/form-scope.service';\nimport { SectionHelperService } from '../../services/section-helper.service';\nimport { SectionScopeService } from '../../services/section-scope.service';\nimport { LegacyRuntimeContext, UpdateData } from '../../types';\nimport { SectionsBinderHelper } from '../../utils/sections-binder.helper';\n\n@Directive()\nexport class SectionContextAware implements OnInit {\n  public controlName!: string;\n  public qtyControlName!: string;\n\n  // @Input()\n  public form!: FormGroup;\n  public section!: Section;\n\n  constructor(protected formScope: FormScopeService, protected sectionScope: SectionScopeService) {}\n\n  public ngOnInit(): void {\n    this.form = this.formScope.form;\n    this.section = this.sectionScope.section;\n\n    this.initControlNames();\n  }\n\n  public initControlNames(): void {\n    this.controlName = this.section.id;\n    this.qtyControlName = this.section.id + 'qty';\n  }\n\n  //TODO ALE CONSIDER STORE INSTEAD OF CALCULATE EVERY TIME\n  public isAddAllowed(quantityToAdd: number = 1): boolean {\n    return this.section.model\n      ? SectionsBinderHelper.isAddAllowed(this.section.model, this.section.boundData.name, quantityToAdd)\n      : false;\n  }\n\n  public isRemoveAllowed(quantityToRemove: number = 1): boolean {\n    return this.section.model\n      ? SectionsBinderHelper.isRemoveAllowed(this.section.model, this.section.boundData.name, quantityToRemove)\n      : false;\n  }\n\n  public handleCreate(valueOption?: any): void {\n    if (!this.isAddAllowed()) {\n      return;\n    }\n\n    const updateData: UpdateData = {\n      id: this.section.id,\n      action: 'create',\n      valueOption: EntityUtil.isPresent(valueOption) ? valueOption : void 0,\n    };\n\n    this.formScope.publishFormUpdate(updateData);\n  }\n\n  public handleChange(valueOption?: any): void {\n    const updateData: UpdateData = {\n      id: this.section.id,\n      action: 'update',\n      valueOption: EntityUtil.isPresent(valueOption) ? valueOption : void 0,\n    };\n\n    this.formScope.publishFormUpdate(updateData);\n  }\n\n  public handleQtyChange(valueOption: any): void {\n    const updateData: UpdateData = {\n      id: this.section.id,\n      action: 'qtyUpdate',\n      valueOption: valueOption,\n    };\n\n    this.formScope.publishFormUpdate(updateData);\n  }\n\n  public handleRemove(valueOption: string): void {\n    const updateData: UpdateData = {\n      id: this.section.id,\n      action: 'remove',\n      valueOption: valueOption,\n    };\n\n    this.formScope.publishFormUpdate(updateData);\n  }\n\n  public handleCopy(valueOption: string): void {\n    const updateData: UpdateData = {\n      id: this.section.id,\n      action: 'copy',\n      valueOption: valueOption,\n    };\n\n    this.formScope.publishFormUpdate(updateData);\n  }\n}\n\n@Directive({\n  // eslint-disable-next-line @angular-eslint/directive-selector\n  selector: 'line-item',\n  exportAs: 'liApi',\n})\nexport class LineItemDirective implements OnInit {\n  public section!: Section;\n  public lineItem?: LineItem;\n\n  constructor(\n    private formScope: FormScopeService,\n    private sectionScope: SectionScopeService,\n    private configurationService: ConfigurationService,\n  ) {}\n\n  public ngOnInit(): void {\n    this.section = this.sectionScope.section;\n    this.lineItem = this.section.model;\n  }\n\n  public handlePatch(rootLineItem: any): void {\n    const updateData: UpdateData = {\n      id: this.sectionScope.section.id,\n      action: 'patch',\n      valueOption: rootLineItem,\n    };\n\n    this.formScope.publishFormUpdate(updateData);\n  }\n\n  public configure(runtimeContext: LegacyRuntimeContext, configurableRamp: LineItem): Promise<LineItem> {\n    return this.configurationService\n      .configure(runtimeContext, { configurableRamp })\n      .pipe(take(1))\n      .toPromise() as Promise<LineItem>;\n  }\n}\n\n@Directive({\n  // eslint-disable-next-line @angular-eslint/directive-selector\n  selector: 'velo-port',\n  exportAs: 'portApi',\n})\nexport class VeloPortDirective extends SectionContextAware implements OnInit {\n  public valueQuantities: { [index: string]: number } = {};\n\n  constructor(formScope: FormScopeService, sectionScope: SectionScopeService) {\n    super(formScope, sectionScope);\n  }\n\n  private handlePriceAdjustment(action: string, valueOption: string, amount: number): void {\n    const updateData: UpdateData = {\n      id: this.section.id,\n      action,\n      valueOption,\n      options: { amount },\n    };\n\n    this.formScope.publishFormUpdate(updateData);\n  }\n\n  public override ngOnInit(): void {\n    super.ngOnInit();\n\n    this.initQuantity();\n  }\n\n  public handleUpsert(valueOption?: any, event?: Event): void {\n    if (EntityUtil.isPresent(this.valueQuantities[valueOption]) && EntityUtil.isPresent(event)) {\n      event?.preventDefault();\n      return;\n    } else if (Object.keys(this.valueQuantities).length > 0) {\n      this.handleChange(valueOption);\n    } else {\n      this.handleCreate(valueOption);\n    }\n  }\n\n  public isActive(valueOption?: any): boolean {\n    return EntityUtil.isPresent(this.valueQuantities[valueOption]);\n  }\n\n  private initQuantity(): void {\n    this.valueQuantities = this.section.model\n      ? SectionsBinderHelper.getQuantityGroupByValue(this.section.model, this.section.boundData.name)\n      : {};\n  }\n\n  //Quantity Stepper Functions\n  public handleNextVal(valueOption: string): void {\n    let initQty = this.valueQuantities[valueOption] || 0;\n\n    if (this.isAddAllowed()) {\n      if (initQty > 0) {\n        const typeSection = SectionHelperService.findSectionForValue(this.section, valueOption);\n\n        if (typeSection) {\n          this.form.controls[typeSection.id + 'qty'].setValue(++initQty);\n\n          this.handleQtyChange(valueOption);\n        }\n      } else {\n        this.handleCreate(valueOption);\n      }\n    }\n  }\n\n  public handlePrevVal(valueOption: string): void {\n    let initQty = this.valueQuantities[valueOption] || 0;\n\n    if (this.isRemoveAllowed()) {\n      if (initQty < 2) {\n        this.handleRemove(valueOption);\n      } else {\n        const typeSection = SectionHelperService.findSectionForValue(this.section, valueOption);\n\n        if (typeSection) {\n          this.form.controls[typeSection.id + 'qty'].setValue(--initQty);\n\n          this.handleQtyChange(valueOption);\n        }\n      }\n    }\n  }\n\n  public handleManualQtyChange(valueOption: string, qtyVal: any): void {\n    const initQty = this.valueQuantities[valueOption] || 0;\n    if (isNaN(+qtyVal) || +qtyVal < 0 || initQty === +qtyVal) {\n      return;\n    }\n\n    const newQty = +qtyVal;\n\n    if (initQty === 0) {\n      if (this.isAddAllowed(newQty)) {\n        this.form.controls[this.qtyControlName].setValue(newQty);\n        this.handleCreate(valueOption);\n      }\n    } else if (newQty === 0) {\n      if (this.isRemoveAllowed()) {\n        this.handleRemove(valueOption);\n      }\n    } else {\n      const typeSection = SectionHelperService.findSectionForValue(this.section, valueOption);\n\n      if (typeSection) {\n        const dif = newQty - initQty;\n\n        const isAllowed = dif > 0 ? this.isAddAllowed(dif) : this.isRemoveAllowed(dif * -1);\n\n        if (isAllowed) {\n          this.form.controls[typeSection.id + 'qty'].setValue(newQty);\n          this.handleQtyChange(valueOption);\n        }\n      }\n    }\n  }\n\n  public handleNetPriceAdjustment(valueOption: string, amount: number): void {\n    this.handlePriceAdjustment('adjustNetPrice', valueOption, amount);\n  }\n\n  public handleListPriceAdjustment(valueOption: string, amount: number): void {\n    this.handlePriceAdjustment('adjustListPrice', valueOption, amount);\n  }\n}\n\n@Component({\n  // moduleId: module.id,\n  // eslint-disable-next-line @angular-eslint/component-selector\n  selector: 'velo-dropdown',\n  template: `\n    <div class=\"input-form-input div-inline\" [formGroup]=\"form\">\n      <label [for]=\"controlName\">{{ section.label }}</label>\n      <div class=\"form-control-wrapper\">\n        <select [id]=\"controlName\" [formControlName]=\"controlName\" class=\"form-control\">\n          <option *ngFor=\"let valueOption of section.sectionValue?.valueOptions\" [ngValue]=\"valueOption\">\n            {{ section.sectionValue?.displayValues?.[valueOption] || valueOption }}\n          </option>\n        </select>\n      </div>\n    </div>\n  `,\n})\nexport class VeloDropdownComponent extends SectionContextAware {\n  constructor(formScope: FormScopeService, sectionScope: SectionScopeService) {\n    super(formScope, sectionScope);\n  }\n}\n\n@Component({\n  // moduleId: module.id,\n  // eslint-disable-next-line @angular-eslint/component-selector\n  selector: 'velo-quantity',\n  template: `\n    <div class=\"input-form-input div-inline quantity-form-input\" [formGroup]=\"form\">\n      <label [for]=\"qtyControlName\"> Quantity </label>\n      <div class=\"form-control-wrapper\">\n        <input\n          [id]=\"controlName\"\n          [formControlName]=\"qtyControlName\"\n          [attr.disabled]=\"isAddAllowed() === true ? null : true\"\n          type=\"text\"\n          class=\"form-control\"\n          size=\"3\"\n        />\n\n        <div\n          class=\"validation-message\"\n          [hidden]=\"form.controls[qtyControlName].valid || form.controls[qtyControlName].pristine\"\n        >\n          <div *ngFor=\"let key of form.controls[qtyControlName].errors | values\">\n            <span> {{ form.controls[qtyControlName].errors?.[key].message }}</span>\n          </div>\n        </div>\n      </div>\n    </div>\n  `,\n})\nexport class VeloQuantityComponent extends SectionContextAware {\n  constructor(formScope: FormScopeService, sectionScope: SectionScopeService) {\n    super(formScope, sectionScope);\n  }\n}\n\n@Component({\n  // moduleId: module.id,\n  // eslint-disable-next-line @angular-eslint/component-selector\n  selector: 'velo-quantity-button',\n  template: `\n    <div class=\"input-form-input div-inline quantity-form-input\">\n      <div class=\"form-control-wrapper\">\n        <a href=\"javascript:void(0);\" (click)=\"handleCreate()\">\n          <div class=\"add-config-control\" [attr.disabled]=\"isAddAllowed() === true ? null : true\">\n            <i class=\"fa fa-plus plus-icon\"></i>\n          </div>\n        </a>\n      </div>\n    </div>\n  `,\n})\nexport class VeloQuantityButtonComponent extends SectionContextAware {\n  constructor(formScope: FormScopeService, sectionScope: SectionScopeService) {\n    super(formScope, sectionScope);\n  }\n}\n"]}

package/esm2020/runtime/execution/directives/vl-approval.directive.mjs

@@ -0,0 +1,23 @@
+import { Directive } from '@angular/core';
+import { QuoteApiService } from '@veloceapps/api';
+import * as i0 from "@angular/core";
+import * as i1 from "@veloceapps/api";
+export class VlApprovalDirective {
+    constructor(repo) {
+        this.repo = repo;
+    }
+    submitQuote(quoteDraft) {
+        return this.repo.submitQuote(quoteDraft).toPromise();
+    }
+}
+VlApprovalDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: VlApprovalDirective, deps: [{ token: i1.QuoteApiService }], target: i0.ɵɵFactoryTarget.Directive });
+VlApprovalDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.8", type: VlApprovalDirective, selector: "vl-approval", exportAs: ["approvalApi"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: VlApprovalDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: 'vl-approval',
+                    exportAs: 'approvalApi',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.QuoteApiService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmwtYXBwcm92YWwuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9zZGsvcnVudGltZS9leGVjdXRpb24vZGlyZWN0aXZlcy92bC1hcHByb3ZhbC5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMxQyxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0saUJBQWlCLENBQUM7OztBQVFsRCxNQUFNLE9BQU8sbUJBQW1CO0lBQzlCLFlBQW9CLElBQXFCO1FBQXJCLFNBQUksR0FBSixJQUFJLENBQWlCO0lBQUcsQ0FBQztJQUV0QyxXQUFXLENBQUMsVUFBc0I7UUFDdkMsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxVQUFVLENBQUMsQ0FBQyxTQUFTLEVBQUUsQ0FBQztJQUN2RCxDQUFDOztnSEFMVSxtQkFBbUI7b0dBQW5CLG1CQUFtQjsyRkFBbkIsbUJBQW1CO2tCQUwvQixTQUFTO21CQUFDO29CQUNULDhEQUE4RDtvQkFDOUQsUUFBUSxFQUFFLGFBQWE7b0JBQ3ZCLFFBQVEsRUFBRSxhQUFhO2lCQUN4QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgUXVvdGVBcGlTZXJ2aWNlIH0gZnJvbSAnQHZlbG9jZWFwcHMvYXBpJztcbmltcG9ydCB7IFF1b3RlRHJhZnQgfSBmcm9tICdAdmVsb2NlYXBwcy9jb3JlJztcblxuQERpcmVjdGl2ZSh7XG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAYW5ndWxhci1lc2xpbnQvZGlyZWN0aXZlLXNlbGVjdG9yXG4gIHNlbGVjdG9yOiAndmwtYXBwcm92YWwnLFxuICBleHBvcnRBczogJ2FwcHJvdmFsQXBpJyxcbn0pXG5leHBvcnQgY2xhc3MgVmxBcHByb3ZhbERpcmVjdGl2ZSB7XG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgcmVwbzogUXVvdGVBcGlTZXJ2aWNlKSB7fVxuXG4gIHB1YmxpYyBzdWJtaXRRdW90ZShxdW90ZURyYWZ0OiBRdW90ZURyYWZ0KTogUHJvbWlzZTxhbnk+IHtcbiAgICByZXR1cm4gdGhpcy5yZXBvLnN1Ym1pdFF1b3RlKHF1b3RlRHJhZnQpLnRvUHJvbWlzZSgpO1xuICB9XG59XG4iXX0=

package/esm2020/runtime/execution/directives/vl-document-attachments.directive.mjs

@@ -0,0 +1,36 @@
+import { Directive } from '@angular/core';
+import { DocumentAttachmentApiService } from '@veloceapps/api';
+import * as i0 from "@angular/core";
+import * as i1 from "@veloceapps/api";
+export class VlDocumentAttachmentsDirective {
+    constructor(service) {
+        this.service = service;
+    }
+    getAttachments(searchRequest) {
+        return this.service.getAttachments(searchRequest).toPromise();
+    }
+    createAttachment(attachment, file, reportProgress) {
+        const observable = this.service.createAttachment(attachment, file, reportProgress);
+        return reportProgress ? observable : observable.toPromise();
+    }
+    updateAttachment(id, attachment) {
+        return this.service.updateAttachment(id, attachment).toPromise();
+    }
+    getAttachmentFile(id, isPreventDownload) {
+        return this.service.getAttachmentFile(id, isPreventDownload).toPromise();
+    }
+    removeAttachment(id) {
+        return this.service.removeAttachment(id).toPromise();
+    }
+}
+VlDocumentAttachmentsDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: VlDocumentAttachmentsDirective, deps: [{ token: i1.DocumentAttachmentApiService }], target: i0.ɵɵFactoryTarget.Directive });
+VlDocumentAttachmentsDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.8", type: VlDocumentAttachmentsDirective, selector: "vl-document-attachments", exportAs: ["documentAttachmentsApi"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: VlDocumentAttachmentsDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: 'vl-document-attachments',
+                    exportAs: 'documentAttachmentsApi',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DocumentAttachmentApiService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/runtime/execution/directives/vl-document-templates.directive.mjs

@@ -0,0 +1,60 @@
+import { Directive } from '@angular/core';
+import { DocumentTemplatesApiService } from '@veloceapps/api';
+import { take } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@veloceapps/api";
+export class VlDocumentTemplatesDirective {
+    constructor(documentTemplatesApiService) {
+        this.documentTemplatesApiService = documentTemplatesApiService;
+        /**
+         * @deprecated Use `generateDocument` instead
+         */
+        // eslint-disable-next-line @typescript-eslint/member-ordering
+        this.generateDocumentNew = this.generateDocument;
+    }
+    getTemplates(tag) {
+        return this.documentTemplatesApiService.getTemplates(tag).toPromise();
+    }
+    upsertTemplate(template, templateFile) {
+        return this.documentTemplatesApiService
+            .upsertTemplate(template, templateFile)
+            .toPromise();
+    }
+    removeTemplate(id) {
+        return this.documentTemplatesApiService.removeTemplate(id).toPromise();
+    }
+    cloneTemplate(id) {
+        return this.documentTemplatesApiService.cloneTemplate(id).toPromise();
+    }
+    downloadTemplate(id) {
+        return this.documentTemplatesApiService.downloadTemplateFile(id).toPromise();
+    }
+    generateDocument(template, quoteDraft, params) {
+        return this.documentTemplatesApiService.generateDocument(template, quoteDraft, params).pipe(take(1));
+    }
+    generateDocumentData(template, quoteDraft, params) {
+        return this.documentTemplatesApiService.generateDocumentData(template, quoteDraft, params).pipe(take(1));
+    }
+    getAttachments(searchRequest) {
+        return this.documentTemplatesApiService.getAttachments(searchRequest).toPromise();
+    }
+    getAttachmentFile(id) {
+        return this.documentTemplatesApiService.getAttachmentFile(id).toPromise();
+    }
+    createAttachment(attachment, file) {
+        return this.documentTemplatesApiService.createAttachment(attachment, file).toPromise();
+    }
+    removeAttachment(id) {
+        return this.documentTemplatesApiService.removeAttachment(id).toPromise();
+    }
+}
+VlDocumentTemplatesDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: VlDocumentTemplatesDirective, deps: [{ token: i1.DocumentTemplatesApiService }], target: i0.ɵɵFactoryTarget.Directive });
+VlDocumentTemplatesDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.8", type: VlDocumentTemplatesDirective, selector: "[vlQuoteTemplates]", exportAs: ["quoteTemplateApi"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: VlDocumentTemplatesDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[vlQuoteTemplates]',
+                    exportAs: 'quoteTemplateApi',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DocumentTemplatesApiService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/runtime/execution/directives/vl-quote.directive.mjs

@@ -0,0 +1,42 @@
+import { Directive } from '@angular/core';
+import { QuoteApiService } from '@veloceapps/api';
+import { EntityUtil } from '@veloceapps/core';
+import { RuntimeService } from '../../services/runtime.service';
+import { LineItemUtil } from '../../utils/line-item.util';
+import * as i0 from "@angular/core";
+import * as i1 from "@veloceapps/api";
+import * as i2 from "../../services/runtime.service";
+export class VlQuoteDirective {
+    constructor(quoteApiService, runtimeService) {
+        this.quoteApiService = quoteApiService;
+        this.runtimeService = runtimeService;
+    }
+    getQuote(quoteId) {
+        return this.quoteApiService.getQuoteDraft(quoteId).toPromise();
+    }
+    upsertQuote(quoteDraft) {
+        return this.quoteApiService.upsertQuote(quoteDraft).toPromise();
+    }
+    configureQuote(quoteDraft, rootLineItemId) {
+        const rootLineItem = EntityUtil.findById(rootLineItemId, quoteDraft.currentState);
+        const asset = quoteDraft.initialState?.find(a => a.id === rootLineItem.assetId);
+        const { context } = quoteDraft;
+        const states = {
+            configurableRamp: LineItemUtil.removeDeletedItems(rootLineItem),
+            currentState: quoteDraft.currentState,
+            asset,
+        };
+        this.runtimeService.updateRuntime(states, context.properties);
+    }
+}
+VlQuoteDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: VlQuoteDirective, deps: [{ token: i1.QuoteApiService }, { token: i2.RuntimeService }], target: i0.ɵɵFactoryTarget.Directive });
+VlQuoteDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.8", type: VlQuoteDirective, selector: "vl-quote", exportAs: ["quoteApi"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: VlQuoteDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: 'vl-quote',
+                    exportAs: 'quoteApi',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.QuoteApiService }, { type: i2.RuntimeService }]; } });
+//# sourceMappingURL=data:application/json;base64,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