@veloceapps/sdk 0.0.0-watch

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

@@ -0,0 +1,121 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/form-scope.service";
+import * as i2 from "../../../services/collapsible-state.service";
+import * as i3 from "../../../services/section-scope.service";
+import * as i4 from "primeng/api";
+import * as i5 from "@angular/forms";
+import * as i6 from "@angular/common";
+import * as i7 from "ngx-bootstrap/popover";
+import * as i8 from "@veloce/core";
+export class VeloTypeComponent {
+    constructor(formScope, collapsibleState, sectionScope, messageService) {
+        var _a, _b;
+        this.formScope = formScope;
+        this.collapsibleState = collapsibleState;
+        this.sectionScope = sectionScope;
+        this.messageService = messageService;
+        this.messageBucketId = 'ui-runtime';
+        this.indent = 1;
+        this.prices = [];
+        this.form = this.formScope.form;
+        this.section = this.sectionScope.section;
+        this.indent = this.sectionScope.indent;
+        this.controlName = this.section.id;
+        this.qtyControlName = this.section.id + 'qty';
+        this.displayName =
+            (((_a = this.section.model) === null || _a === void 0 ? void 0 : _a.properties) && this.section.model.properties.displayName) || ((_b = this.section.model) === null || _b === void 0 ? void 0 : _b.type) || '';
+    }
+    ngOnInit() {
+        var _a, _b;
+        if (this.section.pricingEnabled) {
+            this.prices = this.getPrices();
+        }
+        if (this.section.controlType === 'MESSAGE') {
+            this.messageService.clear(this.messageBucketId);
+            (_b = (_a = this.section.model) === null || _a === void 0 ? void 0 : _a.messages) === null || _b === void 0 ? void 0 : _b.forEach(message => {
+                this.messageService.add({ key: this.messageBucketId, summary: message });
+            });
+        }
+    }
+    handleRemove() {
+        const updateData = {
+            id: this.section.id,
+            action: 'remove',
+        };
+        this.formScope.publishFormUpdate(updateData);
+    }
+    handleQuantityUpdate() {
+        const updateData = {
+            id: this.section.id,
+            action: 'qtyUpdate',
+        };
+        this.formScope.publishFormUpdate(updateData);
+    }
+    toggleCollapse() {
+        if (this.section.model) {
+            this.collapsibleState.toggleCollapse(this.section.model.id);
+        }
+    }
+    getPrices() {
+        var _a;
+        let prices = [];
+        if ((_a = this.section.model) === null || _a === void 0 ? void 0 : _a.chargeItems) {
+            prices = this.section.model.chargeItems.map(pi => {
+                const price = {
+                    listPrice: pi.listPrice,
+                    netPrice: pi.netPrice,
+                    chargeMethod: pi.chargeMethod,
+                    chargeType: pi.chargeType,
+                };
+                return price;
+            });
+        }
+        const oneTime = {
+            chargeMethod: 'ONE_TIME',
+            netPrice: 0,
+            listPrice: 0,
+            chargeType: '',
+        };
+        const recurring = {
+            chargeMethod: 'RECURRING',
+            netPrice: 0,
+            listPrice: 0,
+            chargeType: '',
+        };
+        prices.forEach(p => {
+            if (p.chargeMethod === oneTime.chargeMethod) {
+                this.add(oneTime, p);
+            }
+            if (p.chargeMethod === recurring.chargeMethod) {
+                this.add(recurring, p);
+            }
+        });
+        const result = [];
+        if (oneTime.listPrice > 0) {
+            result.push(oneTime);
+        }
+        if (recurring.listPrice > 0) {
+            result.push(recurring);
+        }
+        return result;
+    }
+    add(target, src) {
+        target.netPrice = target.netPrice + src.netPrice;
+        target.listPrice = target.listPrice + src.listPrice;
+        if (src.explanation) {
+            target.explanation = src.explanation;
+        }
+    }
+}
+VeloTypeComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: VeloTypeComponent, deps: [{ token: i1.FormScopeService }, { token: i2.CollapsibleStateService }, { token: i3.SectionScopeService }, { token: i4.MessageService }], target: i0.ɵɵFactoryTarget.Component });
+VeloTypeComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.15", type: VeloTypeComponent, selector: "velo-type", ngImport: i0, template: "<div class=\"container-box div-block collapsed container-box-bordered\" [formGroup]=\"form\">\n  <div class=\"box-title\">\n    <div class=\"header clearfix\">\n      <div>\n        <div class=\"header-label div-inline\">\n          {{ displayName }}\n          <span *ngIf=\"prices.length > 0\">\n            <span>${{ prices[0].netPrice }}</span>\n            <span *ngIf=\"prices.length > 1\">\n              <span>, </span>\n              <span>${{ prices[1].netPrice }}</span>\n            </span>\n          </span>\n        </div>\n\n        <div class=\"header-qty-container input-form-input\">\n          <input\n            [id]=\"qtyControlName\"\n            [formControlName]=\"qtyControlName\"\n            (blur)=\"form.controls[qtyControlName].valid && handleQuantityUpdate()\"\n            type=\"text\"\n            class=\"form-control\"\n            size=\"3\"\n          />\n          <div class=\"validation-message\">\n            <div *ngFor=\"let key of form.controls[qtyControlName].errors | values\">\n              <span>\n                {{ form.controls[qtyControlName]?.errors?.[key].message }}\n              </span>\n            </div>\n            <span *ngIf=\"form.controls[qtyControlName].valid\"> &nbsp; </span>\n          </div>\n          <span *ngIf=\"prices.length > 0\">\n            <div>{{ prices[0].explanation }}</div>\n            <span *ngIf=\"prices.length > 1 && prices[1].explanation\">\n              <div>{{ prices[1].explanation }}</div>\n            </span>\n          </span>\n        </div>\n      </div>\n    </div>\n\n    <div class=\"box-actions\">\n      <ng-container *ngIf=\"section.controlType !== 'MESSAGE'\">\n        <ng-template #msgTemplate>\n          <div class=\"runtime-info-message\">\n            <ul class=\"message-text\">\n              <li *ngFor=\"let message of section.model?.messages\">{{ message }}</li>\n            </ul>\n          </div>\n        </ng-template>\n\n        <div\n          class=\"box-action-button\"\n          *ngIf=\"(section.model?.messages?.length ?? 0) > 0\"\n          [popover]=\"msgTemplate\"\n          placement=\"left\"\n          container=\"body\"\n          [isOpen]=\"true\"\n        >\n          <a href=\"javascript:void(0);\">\n            <i class=\"fa fa-info check-icon\"></i>\n          </a>\n        </div>\n      </ng-container>\n\n      <div\n        class=\"box-action-button\"\n        (click)=\"toggleCollapse()\"\n        [hidden]=\"!section.children || section.children.length < 1\"\n      >\n        <a><i class=\"fa fa-chevron-down check-icon\"></i></a>\n      </div>\n\n      <div class=\"box-action-button\" (click)=\"handleRemove()\">\n        <a><i class=\"fa fa-trash-o check-icon\"></i></a>\n      </div>\n    </div>\n  </div>\n\n  <ng-content></ng-content>\n</div>\n", directives: [{ type: i5.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i5.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { 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]" }, { type: i5.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i5.FormControlName, selector: "[formControlName]", inputs: ["disabled", "formControlName", "ngModel"], outputs: ["ngModelChange"] }, { type: i6.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i7.PopoverDirective, selector: "[popover]", inputs: ["outsideClick", "containerClass", "isOpen", "adaptivePosition", "popover", "popoverContext", "popoverTitle", "placement", "triggers", "container", "delay"], outputs: ["onShown", "onHidden"], exportAs: ["bs-popover"] }], pipes: { "values": i8.ValuesPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: VeloTypeComponent, decorators: [{
+            type: Component,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/component-selector
+                    selector: 'velo-type',
+                    templateUrl: 'velo-type.component.html',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.FormScopeService }, { type: i2.CollapsibleStateService }, { type: i3.SectionScopeService }, { type: i4.MessageService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"velo-type.component.js","sourceRoot":"","sources":["../../../../../../../../libs/sdk/runtime/execution/components/velo-type/velo-type.component.ts","../../../../../../../../libs/sdk/runtime/execution/components/velo-type/velo-type.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit } from '@angular/core';\nimport { FormGroup } from '@angular/forms';\nimport { RecommendedPrice, Section } from '@veloce/core';\nimport { MessageService } from 'primeng/api';\nimport { CollapsibleStateService } from '../../../services/collapsible-state.service';\nimport { FormScopeService } from '../../../services/form-scope.service';\nimport { SectionScopeService } from '../../../services/section-scope.service';\nimport { UpdateData } from '../../../types';\n\n@Component({\n  // eslint-disable-next-line @angular-eslint/component-selector\n  selector: 'velo-type',\n  templateUrl: 'velo-type.component.html',\n})\nexport class VeloTypeComponent implements OnInit {\n  readonly messageBucketId = 'ui-runtime';\n\n  controlName: string;\n  qtyControlName: string;\n  displayName: string;\n  indent = 1;\n\n  form: FormGroup;\n  section: Section;\n\n  prices: RecommendedPrice[] = [];\n\n  constructor(\n    private formScope: FormScopeService,\n    private collapsibleState: CollapsibleStateService,\n    private sectionScope: SectionScopeService,\n    private messageService: MessageService,\n  ) {\n    this.form = this.formScope.form;\n    this.section = this.sectionScope.section;\n    this.indent = this.sectionScope.indent;\n\n    this.controlName = this.section.id;\n    this.qtyControlName = this.section.id + 'qty';\n    this.displayName =\n      (this.section.model?.properties && this.section.model.properties.displayName) || this.section.model?.type || '';\n  }\n\n  ngOnInit(): void {\n    if (this.section.pricingEnabled) {\n      this.prices = this.getPrices();\n    }\n\n    if (this.section.controlType === 'MESSAGE') {\n      this.messageService.clear(this.messageBucketId);\n\n      this.section.model?.messages?.forEach(message => {\n        this.messageService.add({ key: this.messageBucketId, summary: message });\n      });\n    }\n  }\n\n  handleRemove(): void {\n    const updateData: UpdateData = {\n      id: this.section.id,\n      action: 'remove',\n    };\n\n    this.formScope.publishFormUpdate(updateData);\n  }\n\n  handleQuantityUpdate(): void {\n    const updateData: UpdateData = {\n      id: this.section.id,\n      action: 'qtyUpdate',\n    };\n\n    this.formScope.publishFormUpdate(updateData);\n  }\n\n  toggleCollapse(): void {\n    if (this.section.model) {\n      this.collapsibleState.toggleCollapse(this.section.model.id);\n    }\n  }\n\n  getPrices(): RecommendedPrice[] {\n    let prices: RecommendedPrice[] = [];\n    if (this.section.model?.chargeItems) {\n      prices = this.section.model.chargeItems.map(pi => {\n        const price: RecommendedPrice = {\n          listPrice: pi.listPrice,\n          netPrice: pi.netPrice,\n          chargeMethod: pi.chargeMethod,\n          chargeType: pi.chargeType,\n        };\n\n        return price;\n      });\n    }\n\n    const oneTime: RecommendedPrice = {\n      chargeMethod: 'ONE_TIME',\n      netPrice: 0,\n      listPrice: 0,\n      chargeType: '',\n    };\n\n    const recurring: RecommendedPrice = {\n      chargeMethod: 'RECURRING',\n      netPrice: 0,\n      listPrice: 0,\n      chargeType: '',\n    };\n\n    prices.forEach(p => {\n      if (p.chargeMethod === oneTime.chargeMethod) {\n        this.add(oneTime, p);\n      }\n      if (p.chargeMethod === recurring.chargeMethod) {\n        this.add(recurring, p);\n      }\n    });\n\n    const result: RecommendedPrice[] = [];\n    if (oneTime.listPrice > 0) {\n      result.push(oneTime);\n    }\n    if (recurring.listPrice > 0) {\n      result.push(recurring);\n    }\n\n    return result;\n  }\n\n  private add(target: RecommendedPrice, src: RecommendedPrice): void {\n    target.netPrice = target.netPrice + src.netPrice;\n    target.listPrice = target.listPrice + src.listPrice;\n    if (src.explanation) {\n      target.explanation = src.explanation;\n    }\n  }\n}\n","<div class=\"container-box div-block collapsed container-box-bordered\" [formGroup]=\"form\">\n  <div class=\"box-title\">\n    <div class=\"header clearfix\">\n      <div>\n        <div class=\"header-label div-inline\">\n          {{ displayName }}\n          <span *ngIf=\"prices.length > 0\">\n            <span>${{ prices[0].netPrice }}</span>\n            <span *ngIf=\"prices.length > 1\">\n              <span>, </span>\n              <span>${{ prices[1].netPrice }}</span>\n            </span>\n          </span>\n        </div>\n\n        <div class=\"header-qty-container input-form-input\">\n          <input\n            [id]=\"qtyControlName\"\n            [formControlName]=\"qtyControlName\"\n            (blur)=\"form.controls[qtyControlName].valid && handleQuantityUpdate()\"\n            type=\"text\"\n            class=\"form-control\"\n            size=\"3\"\n          />\n          <div class=\"validation-message\">\n            <div *ngFor=\"let key of form.controls[qtyControlName].errors | values\">\n              <span>\n                {{ form.controls[qtyControlName]?.errors?.[key].message }}\n              </span>\n            </div>\n            <span *ngIf=\"form.controls[qtyControlName].valid\"> &nbsp; </span>\n          </div>\n          <span *ngIf=\"prices.length > 0\">\n            <div>{{ prices[0].explanation }}</div>\n            <span *ngIf=\"prices.length > 1 && prices[1].explanation\">\n              <div>{{ prices[1].explanation }}</div>\n            </span>\n          </span>\n        </div>\n      </div>\n    </div>\n\n    <div class=\"box-actions\">\n      <ng-container *ngIf=\"section.controlType !== 'MESSAGE'\">\n        <ng-template #msgTemplate>\n          <div class=\"runtime-info-message\">\n            <ul class=\"message-text\">\n              <li *ngFor=\"let message of section.model?.messages\">{{ message }}</li>\n            </ul>\n          </div>\n        </ng-template>\n\n        <div\n          class=\"box-action-button\"\n          *ngIf=\"(section.model?.messages?.length ?? 0) > 0\"\n          [popover]=\"msgTemplate\"\n          placement=\"left\"\n          container=\"body\"\n          [isOpen]=\"true\"\n        >\n          <a href=\"javascript:void(0);\">\n            <i class=\"fa fa-info check-icon\"></i>\n          </a>\n        </div>\n      </ng-container>\n\n      <div\n        class=\"box-action-button\"\n        (click)=\"toggleCollapse()\"\n        [hidden]=\"!section.children || section.children.length < 1\"\n      >\n        <a><i class=\"fa fa-chevron-down check-icon\"></i></a>\n      </div>\n\n      <div class=\"box-action-button\" (click)=\"handleRemove()\">\n        <a><i class=\"fa fa-trash-o check-icon\"></i></a>\n      </div>\n    </div>\n  </div>\n\n  <ng-content></ng-content>\n</div>\n"]}

package/esm2015/runtime/execution/directives/section-script.directive.js

@@ -0,0 +1,242 @@
+import { CurrencyPipe, DOCUMENT } from '@angular/common';
+import { Directive, Inject } from '@angular/core';
+import { EntityUtil, PagedEntity, UUID } from '@veloce/core';
+import * as _ from 'lodash';
+import * as moment from 'moment';
+import * as rxjs from 'rxjs';
+import * as rxjsOperators from 'rxjs/operators';
+import { SfQueryDirective } from './sf-query.directive';
+import { LineItemDirective } from './velo-port.directive';
+import { VlApprovalDirective } from './vl-approval.directive';
+import { VlDocumentAttachmentsDirective } from './vl-document-attachments.directive';
+import { VlDocumentTemplatesDirective } from './vl-document-templates.directive';
+import { VlQuoteDirective } from './vl-quote.directive';
+import { VlRampDirective } from './vl-ramp.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/forms";
+import * as i4 from "../../services/runtime.service";
+import * as i5 from "../../services/cart.service";
+import * as i6 from "@veloce/sdk/core";
+import * as i7 from "../../services/current-state.service";
+import * as i8 from "./sf-query.directive";
+import * as i9 from "./velo-port.directive";
+import * as i10 from "./vl-quote.directive";
+import * as i11 from "./vl-document-templates.directive";
+import * as i12 from "./vl-ramp.directive";
+import * as i13 from "./vl-approval.directive";
+import * as i14 from "./vl-document-attachments.directive";
+const SHA1 = UUID.SHA1();
+const SCRIPT_GLOBAL_NAME = `$velo`;
+export class SectionScriptDirective {
+    constructor(_document, sfQueryDirective, lineItemDirective, quoteDirective, documentTemplatesDirective, rampDirective, approvalDirective, documentAttachmentsDirective, formScope, sectionScope, renderer, formBuilder, runtimeService, cdr, cartService, contextService, currentStateService, quoteService) {
+        this._document = _document;
+        this.sfQueryDirective = sfQueryDirective;
+        this.lineItemDirective = lineItemDirective;
+        this.quoteDirective = quoteDirective;
+        this.documentTemplatesDirective = documentTemplatesDirective;
+        this.rampDirective = rampDirective;
+        this.approvalDirective = approvalDirective;
+        this.documentAttachmentsDirective = documentAttachmentsDirective;
+        this.formScope = formScope;
+        this.sectionScope = sectionScope;
+        this.renderer = renderer;
+        this.formBuilder = formBuilder;
+        this.runtimeService = runtimeService;
+        this.cdr = cdr;
+        this.cartService = cartService;
+        this.contextService = contextService;
+        this.currentStateService = currentStateService;
+        this.quoteService = quoteService;
+        this.scriptId = '';
+        this.sessionScope = {};
+    }
+    ngOnInit() {
+        if (!this.scriptExists()) {
+            return;
+        }
+        this.scriptId = this.generateScriptId();
+        this.registry = this.getScriptRegistry();
+        this.sessionScope = this.getSessionScope();
+        if (!this.registry.exists(this.scriptId)) {
+            this.appendScriptElementToDom();
+        }
+        this.initScript();
+        this.registry.doRegister(this.scriptId, this.sectionScope.section.id);
+    }
+    ngAfterViewInit() {
+        var _a;
+        const sharedScriptGlobal = (_a = this.registry) === null || _a === void 0 ? void 0 : _a.getGlobalForScript(this.sectionScope.section.id);
+        if (sharedScriptGlobal) {
+            this.methodApply('afterViewInit', sharedScriptGlobal);
+        }
+    }
+    ngOnDestroy() {
+        if (!this.scriptId) {
+            return;
+        }
+        this.registry.unRegister(this.scriptId, this.sectionScope.section.id);
+        if (!this.registry.exists(this.scriptId)) {
+            this.removeScript();
+            this.registry.removeGlobalForScript(this.scriptId);
+        }
+    }
+    get scope() {
+        if (!this.scriptId || !this.sectionScope.section) {
+            return {};
+        }
+        return Object.assign({}, this.registry.getGlobalForScript(this.sectionScope.section.id) || {}, this.sessionScope);
+    }
+    scriptExists() {
+        var _a, _b, _c, _d;
+        return ((_d = (_c = (_b = (_a = this.sectionScope) === null || _a === void 0 ? void 0 : _a.section) === null || _b === void 0 ? void 0 : _b.script) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0) > 0;
+    }
+    encodeScriptBody() {
+        return this.sectionScope.section.script ? atob(this.sectionScope.section.script) : '';
+    }
+    generateScriptId() {
+        return '_' + SHA1.hex(this.encodeScriptBody());
+    }
+    getScriptRegistry() {
+        return this.formScope.scriptRegistry;
+    }
+    getSessionScope() {
+        return this.formScope.scriptSessionScope;
+    }
+    initScript() {
+        let sharedScriptGlobal = this.registry.getGlobalForScript(this.sectionScope.section.id);
+        if (!EntityUtil.isPresent(sharedScriptGlobal)) {
+            sharedScriptGlobal = {};
+            this.registry.setGlobalForScript(this.sectionScope.section.id, sharedScriptGlobal);
+        }
+        this.methodApply('init', sharedScriptGlobal);
+    }
+    removeScript() {
+        const sharedScriptGlobal = this.registry.getGlobalForScript(this.sectionScope.section.id);
+        this.methodApply('destroy', sharedScriptGlobal);
+        this.removeScriptElementFromDom();
+    }
+    appendScriptElementToDom() {
+        const script = this.scriptFromTemplate(this.encodeScriptBody(), this.scriptId, this.sectionScope.section);
+        this.scriptElement = this.renderer.createElement('script');
+        this.scriptElement.type = `text/javascript`;
+        this.scriptElement.text = script;
+        this.scriptElement.setAttribute('id', this.scriptId);
+        this.renderer.appendChild(this._document.body, this.scriptElement);
+    }
+    removeScriptElementFromDom() {
+        if (!this.scriptElement) {
+            this.scriptElement = this._document.getElementById(this.scriptId);
+        }
+        this.scriptElement.remove();
+    }
+    scriptFromTemplate(scriptBody, scriptId, section) {
+        return `var ${scriptId} = (function (${SCRIPT_GLOBAL_NAME}, form, { section, templates }, sessionScope, formBuilder, runtimeContext, cdr, apis) {
+            ${SCRIPT_GLOBAL_NAME}["form"] = form;
+            ${SCRIPT_GLOBAL_NAME}["section"] = section;
+            ${SCRIPT_GLOBAL_NAME}["templates"] = templates;
+            ${SCRIPT_GLOBAL_NAME}["sessionScope"] = sessionScope;
+            ${SCRIPT_GLOBAL_NAME}["formBuilder"] = formBuilder;
+            ${SCRIPT_GLOBAL_NAME}["runtimeContext"] = runtimeContext;
+            ${SCRIPT_GLOBAL_NAME}["cdr"] = cdr;
+            ${SCRIPT_GLOBAL_NAME}["apis"] = apis;
+
+            ${scriptBody}
+                return ${SCRIPT_GLOBAL_NAME};
+            });
+
+            //# sourceURL=${_.kebabCase(section.label)}.js`;
+    }
+    methodApply(methodName, sharedScriptGlobal) {
+        const args = [
+            sharedScriptGlobal,
+            this.formScope.form,
+            this.sectionScope,
+            this.sessionScope,
+            this.formBuilder,
+            this.runtimeService.getRuntimeContext(),
+            this.cdr,
+            this.getExposedApis(),
+        ];
+        const fnInit = window[`${this.scriptId}`](...args);
+        fnInit && fnInit[methodName] && fnInit[methodName].apply();
+    }
+    getExposedApis() {
+        return {
+            'sf-query': this.sfQueryDirective,
+            'line-item': this.lineItemDirective,
+            'quote-directive': this.quoteDirective,
+            'templates-directive': this.documentTemplatesDirective,
+            'attachments-directive': this.documentAttachmentsDirective,
+            'ramp-directive': this.rampDirective,
+            'approval-directive': this.approvalDirective,
+            entityUtil: EntityUtil,
+            moment,
+            lodash: _,
+            rxjs: Object.assign(Object.assign({}, rxjsOperators), rxjs),
+            PagedEntity,
+            pipes: {
+                currency: CurrencyPipe,
+            },
+            solutionUpdateStarted: this.runtimeService.onSolutionUpdateStartedEvent,
+            solutionUpdated: this.runtimeService.onSolutionProcessed,
+            cartService: this.cartService,
+            configurationContextService: this.contextService,
+            quoteDraft: this.quoteService.quoteSnapshot,
+            currentStateService: this.currentStateService,
+        };
+    }
+}
+SectionScriptDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SectionScriptDirective, deps: [{ token: DOCUMENT }, { token: SfQueryDirective }, { token: LineItemDirective }, { token: VlQuoteDirective }, { token: VlDocumentTemplatesDirective }, { token: VlRampDirective }, { token: VlApprovalDirective }, { token: VlDocumentAttachmentsDirective }, { token: i1.FormScopeService }, { token: i2.SectionScopeService }, { token: i0.Renderer2 }, { token: i3.FormBuilder }, { token: i4.RuntimeService }, { token: i0.ChangeDetectorRef }, { token: i5.ShoppingCartService }, { token: i6.ContextService }, { token: i7.CurrentStateService }, { token: i6.QuoteDraftService }], target: i0.ɵɵFactoryTarget.Directive });
+SectionScriptDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.15", type: SectionScriptDirective, selector: "section-script", providers: [
+        SfQueryDirective,
+        LineItemDirective,
+        VlQuoteDirective,
+        VlDocumentTemplatesDirective,
+        VlRampDirective,
+        VlApprovalDirective,
+        VlDocumentAttachmentsDirective,
+    ], exportAs: ["scriptApi"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SectionScriptDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: 'section-script',
+                    exportAs: 'scriptApi',
+                    providers: [
+                        SfQueryDirective,
+                        LineItemDirective,
+                        VlQuoteDirective,
+                        VlDocumentTemplatesDirective,
+                        VlRampDirective,
+                        VlApprovalDirective,
+                        VlDocumentAttachmentsDirective,
+                    ],
+                }]
+        }], ctorParameters: function () { return [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i8.SfQueryDirective, decorators: [{
+                    type: Inject,
+                    args: [SfQueryDirective]
+                }] }, { type: i9.LineItemDirective, decorators: [{
+                    type: Inject,
+                    args: [LineItemDirective]
+                }] }, { type: i10.VlQuoteDirective, decorators: [{
+                    type: Inject,
+                    args: [VlQuoteDirective]
+                }] }, { type: i11.VlDocumentTemplatesDirective, decorators: [{
+                    type: Inject,
+                    args: [VlDocumentTemplatesDirective]
+                }] }, { type: i12.VlRampDirective, decorators: [{
+                    type: Inject,
+                    args: [VlRampDirective]
+                }] }, { type: i13.VlApprovalDirective, decorators: [{
+                    type: Inject,
+                    args: [VlApprovalDirective]
+                }] }, { type: i14.VlDocumentAttachmentsDirective, decorators: [{
+                    type: Inject,
+                    args: [VlDocumentAttachmentsDirective]
+                }] }, { type: i1.FormScopeService }, { type: i2.SectionScopeService }, { type: i0.Renderer2 }, { type: i3.FormBuilder }, { type: i4.RuntimeService }, { type: i0.ChangeDetectorRef }, { type: i5.ShoppingCartService }, { type: i6.ContextService }, { type: i7.CurrentStateService }, { type: i6.QuoteDraftService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"section-script.directive.js","sourceRoot":"","sources":["../../../../../../../libs/sdk/runtime/execution/directives/section-script.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { CurrencyPipe, DOCUMENT } from '@angular/common';\nimport { AfterViewInit, ChangeDetectorRef, Directive, Inject, OnDestroy, OnInit, Renderer2 } from '@angular/core';\nimport { FormBuilder } from '@angular/forms';\nimport { EntityUtil, PagedEntity, Section, UUID } from '@veloce/core';\nimport { ContextService, QuoteDraftService } from '@veloce/sdk/core';\nimport * as _ from 'lodash';\nimport * as moment from 'moment';\nimport * as rxjs from 'rxjs';\nimport * as rxjsOperators from 'rxjs/operators';\nimport { ShoppingCartService } from '../../services/cart.service';\nimport { CurrentStateService } from '../../services/current-state.service';\nimport { FormScopeService } from '../../services/form-scope.service';\nimport { RuntimeService } from '../../services/runtime.service';\nimport { SectionScopeService } from '../../services/section-scope.service';\nimport { ScriptRegistry } from '../../types/script-registry.types';\nimport { SfQueryDirective } from './sf-query.directive';\nimport { LineItemDirective } from './velo-port.directive';\nimport { VlApprovalDirective } from './vl-approval.directive';\nimport { VlDocumentAttachmentsDirective } from './vl-document-attachments.directive';\nimport { VlDocumentTemplatesDirective } from './vl-document-templates.directive';\nimport { VlQuoteDirective } from './vl-quote.directive';\nimport { VlRampDirective } from './vl-ramp.directive';\n\nconst SHA1 = UUID.SHA1();\nconst SCRIPT_GLOBAL_NAME = `$velo`;\n\n@Directive({\n  // eslint-disable-next-line @angular-eslint/directive-selector\n  selector: 'section-script',\n  exportAs: 'scriptApi',\n  providers: [\n    SfQueryDirective,\n    LineItemDirective,\n    VlQuoteDirective,\n    VlDocumentTemplatesDirective,\n    VlRampDirective,\n    VlApprovalDirective,\n    VlDocumentAttachmentsDirective,\n  ],\n})\nexport class SectionScriptDirective implements OnInit, AfterViewInit, OnDestroy {\n  private scriptElement: any;\n  private scriptId = '';\n  private registry!: ScriptRegistry;\n  private sessionScope: { [index: string]: any } = {};\n\n  constructor(\n    @Inject(DOCUMENT) private _document: Document,\n    @Inject(SfQueryDirective) private sfQueryDirective: SfQueryDirective,\n    @Inject(LineItemDirective) private lineItemDirective: LineItemDirective,\n    @Inject(VlQuoteDirective) private quoteDirective: VlQuoteDirective,\n    @Inject(VlDocumentTemplatesDirective) private documentTemplatesDirective: VlDocumentTemplatesDirective,\n    @Inject(VlRampDirective) private rampDirective: VlRampDirective,\n    @Inject(VlApprovalDirective) private approvalDirective: VlApprovalDirective,\n    @Inject(VlDocumentAttachmentsDirective) private documentAttachmentsDirective: VlDocumentAttachmentsDirective,\n    private formScope: FormScopeService,\n    private sectionScope: SectionScopeService,\n    private renderer: Renderer2,\n    private formBuilder: FormBuilder,\n    private runtimeService: RuntimeService,\n    private cdr: ChangeDetectorRef,\n    private cartService: ShoppingCartService,\n    private contextService: ContextService,\n    private currentStateService: CurrentStateService,\n    private quoteService: QuoteDraftService,\n  ) {}\n\n  ngOnInit(): void {\n    if (!this.scriptExists()) {\n      return;\n    }\n\n    this.scriptId = this.generateScriptId();\n    this.registry = this.getScriptRegistry();\n    this.sessionScope = this.getSessionScope();\n\n    if (!this.registry.exists(this.scriptId)) {\n      this.appendScriptElementToDom();\n    }\n\n    this.initScript();\n\n    this.registry.doRegister(this.scriptId, this.sectionScope.section.id);\n  }\n\n  ngAfterViewInit(): void {\n    const sharedScriptGlobal = this.registry?.getGlobalForScript(this.sectionScope.section.id);\n\n    if (sharedScriptGlobal) {\n      this.methodApply('afterViewInit', sharedScriptGlobal);\n    }\n  }\n\n  ngOnDestroy(): void {\n    if (!this.scriptId) {\n      return;\n    }\n\n    this.registry.unRegister(this.scriptId, this.sectionScope.section.id);\n\n    if (!this.registry.exists(this.scriptId)) {\n      this.removeScript();\n      this.registry.removeGlobalForScript(this.scriptId);\n    }\n  }\n\n  get scope() {\n    if (!this.scriptId || !this.sectionScope.section) {\n      return {};\n    }\n\n    return Object.assign({}, this.registry.getGlobalForScript(this.sectionScope.section.id) || {}, this.sessionScope);\n  }\n\n  private scriptExists(): boolean {\n    return (this.sectionScope?.section?.script?.length ?? 0) > 0;\n  }\n\n  private encodeScriptBody(): string {\n    return this.sectionScope.section.script ? atob(this.sectionScope.section.script) : '';\n  }\n\n  private generateScriptId(): string {\n    return '_' + SHA1.hex(this.encodeScriptBody());\n  }\n\n  private getScriptRegistry() {\n    return this.formScope.scriptRegistry;\n  }\n\n  private getSessionScope() {\n    return this.formScope.scriptSessionScope;\n  }\n\n  private initScript(): void {\n    let sharedScriptGlobal = this.registry.getGlobalForScript(this.sectionScope.section.id);\n\n    if (!EntityUtil.isPresent(sharedScriptGlobal)) {\n      sharedScriptGlobal = {};\n      this.registry.setGlobalForScript(this.sectionScope.section.id, sharedScriptGlobal);\n    }\n\n    this.methodApply('init', sharedScriptGlobal);\n  }\n\n  private removeScript(): void {\n    const sharedScriptGlobal = this.registry.getGlobalForScript(this.sectionScope.section.id);\n\n    this.methodApply('destroy', sharedScriptGlobal);\n\n    this.removeScriptElementFromDom();\n  }\n\n  private appendScriptElementToDom(): void {\n    const script = this.scriptFromTemplate(this.encodeScriptBody(), this.scriptId, this.sectionScope.section);\n\n    this.scriptElement = this.renderer.createElement('script');\n    this.scriptElement.type = `text/javascript`;\n    this.scriptElement.text = script;\n\n    this.scriptElement.setAttribute('id', this.scriptId);\n\n    this.renderer.appendChild(this._document.body, this.scriptElement);\n  }\n\n  private removeScriptElementFromDom(): void {\n    if (!this.scriptElement) {\n      this.scriptElement = this._document.getElementById(this.scriptId);\n    }\n\n    this.scriptElement.remove();\n  }\n\n  private scriptFromTemplate(scriptBody: string, scriptId: string, section: Section): string {\n    return `var ${scriptId} = (function (${SCRIPT_GLOBAL_NAME}, form, { section, templates }, sessionScope, formBuilder, runtimeContext, cdr, apis) {\n            ${SCRIPT_GLOBAL_NAME}[\"form\"] = form;\n            ${SCRIPT_GLOBAL_NAME}[\"section\"] = section;\n            ${SCRIPT_GLOBAL_NAME}[\"templates\"] = templates;\n            ${SCRIPT_GLOBAL_NAME}[\"sessionScope\"] = sessionScope;\n            ${SCRIPT_GLOBAL_NAME}[\"formBuilder\"] = formBuilder;\n            ${SCRIPT_GLOBAL_NAME}[\"runtimeContext\"] = runtimeContext;\n            ${SCRIPT_GLOBAL_NAME}[\"cdr\"] = cdr;\n            ${SCRIPT_GLOBAL_NAME}[\"apis\"] = apis;\n\n            ${scriptBody}\n                return ${SCRIPT_GLOBAL_NAME};\n            });\n\n            //# sourceURL=${_.kebabCase(section.label)}.js`;\n  }\n\n  private methodApply(methodName: string, sharedScriptGlobal: any) {\n    const args = [\n      sharedScriptGlobal,\n      this.formScope.form,\n      this.sectionScope,\n      this.sessionScope,\n      this.formBuilder,\n      this.runtimeService.getRuntimeContext(),\n      this.cdr,\n      this.getExposedApis(),\n    ];\n\n    const fnInit = (window as any)[`${this.scriptId}`](...args);\n\n    fnInit && fnInit[methodName] && fnInit[methodName].apply();\n  }\n\n  private getExposedApis() {\n    return {\n      'sf-query': this.sfQueryDirective,\n      'line-item': this.lineItemDirective,\n      'quote-directive': this.quoteDirective,\n      'templates-directive': this.documentTemplatesDirective,\n      'attachments-directive': this.documentAttachmentsDirective,\n      'ramp-directive': this.rampDirective,\n      'approval-directive': this.approvalDirective,\n      entityUtil: EntityUtil,\n      moment,\n      lodash: _,\n      rxjs: { ...rxjsOperators, ...rxjs },\n      PagedEntity,\n      pipes: {\n        currency: CurrencyPipe,\n      },\n      solutionUpdateStarted: this.runtimeService.onSolutionUpdateStartedEvent,\n      solutionUpdated: this.runtimeService.onSolutionProcessed,\n      cartService: this.cartService,\n      configurationContextService: this.contextService,\n      quoteDraft: this.quoteService.quoteSnapshot,\n      currentStateService: this.currentStateService,\n    };\n  }\n}\n"]}

package/esm2015/runtime/execution/directives/sf-query.directive.js

@@ -0,0 +1,34 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@veloce/api";
+export class SfQueryDirective {
+    constructor(apiService) {
+        this.apiService = apiService;
+    }
+    query(searchRequest, objectName) {
+        return this.apiService.query(searchRequest, objectName).toPromise();
+    }
+    describe(objectName, fieldName) {
+        return this.apiService.describe(objectName, fieldName).toPromise();
+    }
+    describe2(objectName, fieldsNames) {
+        return this.apiService.describe2(objectName, fieldsNames).toPromise();
+    }
+    apexGetRequest(path, params) {
+        return this.apiService.apexGetRequest(path, params).toPromise();
+    }
+    apexPostRequest(path, body) {
+        return this.apiService.apexPostRequest(path, body).toPromise();
+    }
+}
+SfQueryDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SfQueryDirective, deps: [{ token: i1.SalesforceApiService }], target: i0.ɵɵFactoryTarget.Directive });
+SfQueryDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.15", type: SfQueryDirective, selector: "sf-query", exportAs: ["sfApi"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SfQueryDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: 'sf-query',
+                    exportAs: 'sfApi',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SalesforceApiService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/runtime/execution/directives/velo-attribute.directive.js

@@ -0,0 +1,86 @@
+import { Directive } from '@angular/core';
+import { EntityUtil } from '@veloce/core';
+import { isDate } from 'lodash';
+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";
+//TODO ALE WE ARE EXTENDING COMPONENT HERE IN PORTS WE ARE EXTENDING DEDICATED CLASS!! TYPES HANDLER IS NO IMPLEMENTED YET
+export class VeloAttributeDirective {
+    constructor(formScope, sectionScope) {
+        this.formScope = formScope;
+        this.sectionScope = sectionScope;
+        this.valueQuantities = {};
+        this.form = this.formScope.form;
+        this.section = this.sectionScope.section;
+    }
+    ngOnInit() {
+        this.initQuantity();
+    }
+    handleChange(valueOption) {
+        const updateData = {
+            id: this.section.id,
+            action: 'update',
+            valueOption,
+        };
+        this.formScope.publishFormUpdate(updateData);
+    }
+    handleChangDate(valueOption) {
+        const oldValue = this.form.controls[this.section.id].value || '';
+        const newValue = isDate(valueOption) ? valueOption.toLocaleDateString('en-us') : '';
+        if (oldValue !== newValue) {
+            this.handleChange(newValue);
+        }
+    }
+    handleRemove() {
+        const updateData = {
+            id: this.section.id,
+            action: 'remove',
+        };
+        this.formScope.publishFormUpdate(updateData);
+    }
+    // TODO ALE THIS IS SPECIFIC STEPPER FUNCTIONS
+    nextVal() {
+        const currentIndex = this.getCurrentValueIndex();
+        const nextValIndex = currentIndex + 1;
+        if (currentIndex != -1 &&
+            this.section.sectionValue &&
+            this.section.sectionValue.valueOptions.length >= nextValIndex) {
+            this.handleChange(this.section.sectionValue.valueOptions[nextValIndex]);
+        }
+    }
+    prevVal() {
+        const currentIndex = this.getCurrentValueIndex();
+        const prevValIndex = currentIndex - 1;
+        if (currentIndex != -1 &&
+            this.section.sectionValue &&
+            this.section.sectionValue.valueOptions.length >= prevValIndex) {
+            this.handleChange(this.section.sectionValue.valueOptions[prevValIndex]);
+        }
+    }
+    initQuantity() {
+        this.valueQuantities = this.section.model
+            ? SectionsBinderHelper.getQuantityGroupByValue(this.section.model, this.section.boundData.name)
+            : {};
+    }
+    getCurrentValueIndex() {
+        const index = -1;
+        const valueOptions = this.section.sectionValue && this.section.sectionValue.valueOptions;
+        const currentValue = this.form.controls[this.section.id].value;
+        if (valueOptions && EntityUtil.isPresent(currentValue)) {
+            return valueOptions.findIndex(valueOption => currentValue === valueOption);
+        }
+        return index;
+    }
+}
+VeloAttributeDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: VeloAttributeDirective, deps: [{ token: i1.FormScopeService }, { token: i2.SectionScopeService }], target: i0.ɵɵFactoryTarget.Directive });
+VeloAttributeDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.15", type: VeloAttributeDirective, selector: "velo-attribute-directive", exportAs: ["attributeApi"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: VeloAttributeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: 'velo-attribute-directive',
+                    exportAs: 'attributeApi',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.FormScopeService }, { type: i2.SectionScopeService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"velo-attribute.directive.js","sourceRoot":"","sources":["../../../../../../../libs/sdk/runtime/execution/directives/velo-attribute.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, OnInit } from '@angular/core';\nimport { FormGroup } from '@angular/forms';\nimport { EntityUtil, Section } from '@veloce/core';\nimport { isDate } from 'lodash';\nimport { FormScopeService } from '../../services/form-scope.service';\nimport { SectionScopeService } from '../../services/section-scope.service';\nimport { UpdateData } from '../../types';\nimport { SectionsBinderHelper } from '../../utils/sections-binder.helper';\n\n//TODO ALE WE ARE EXTENDING COMPONENT HERE IN PORTS WE ARE EXTENDING DEDICATED CLASS!! TYPES HANDLER IS NO IMPLEMENTED YET\n@Directive({\n  // eslint-disable-next-line @angular-eslint/directive-selector\n  selector: 'velo-attribute-directive',\n  exportAs: 'attributeApi',\n})\nexport class VeloAttributeDirective implements OnInit {\n  valueQuantities: { [index: string]: number } = {};\n\n  form: FormGroup;\n  section: Section;\n\n  constructor(private formScope: FormScopeService, private sectionScope: SectionScopeService) {\n    this.form = this.formScope.form;\n    this.section = this.sectionScope.section;\n  }\n\n  ngOnInit(): void {\n    this.initQuantity();\n  }\n\n  handleChange(valueOption?: any): void {\n    const updateData: UpdateData = {\n      id: this.section.id,\n      action: 'update',\n      valueOption,\n    };\n\n    this.formScope.publishFormUpdate(updateData);\n  }\n\n  handleChangDate(valueOption: any): void {\n    const oldValue = this.form.controls[this.section.id].value || '';\n\n    const newValue = isDate(valueOption) ? valueOption.toLocaleDateString('en-us') : '';\n\n    if (oldValue !== newValue) {\n      this.handleChange(newValue);\n    }\n  }\n\n  handleRemove(): void {\n    const updateData: UpdateData = {\n      id: this.section.id,\n      action: 'remove',\n    };\n\n    this.formScope.publishFormUpdate(updateData);\n  }\n\n  // TODO ALE THIS IS SPECIFIC STEPPER FUNCTIONS\n  nextVal(): void {\n    const currentIndex = this.getCurrentValueIndex();\n    const nextValIndex = currentIndex + 1;\n\n    if (\n      currentIndex != -1 &&\n      this.section.sectionValue &&\n      this.section.sectionValue.valueOptions.length >= nextValIndex\n    ) {\n      this.handleChange(this.section.sectionValue.valueOptions[nextValIndex]);\n    }\n  }\n\n  prevVal(): void {\n    const currentIndex = this.getCurrentValueIndex();\n    const prevValIndex = currentIndex - 1;\n\n    if (\n      currentIndex != -1 &&\n      this.section.sectionValue &&\n      this.section.sectionValue.valueOptions.length >= prevValIndex\n    ) {\n      this.handleChange(this.section.sectionValue.valueOptions[prevValIndex]);\n    }\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  private getCurrentValueIndex(): number {\n    const index = -1;\n\n    const valueOptions = this.section.sectionValue && this.section.sectionValue.valueOptions;\n    const currentValue = this.form.controls[this.section.id].value;\n\n    if (valueOptions && EntityUtil.isPresent(currentValue)) {\n      return valueOptions.findIndex(valueOption => currentValue === valueOption);\n    }\n\n    return index;\n  }\n}\n"]}