@veloceapps/sdk 2.0.4 → 2.0.6

package/fesm2015/veloce-sdk.js

@@ -1,6 +1,730 @@
-var index = {};
+import * as i3 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import * as i0 from '@angular/core';
+import { Injectable, Component, ChangeDetectionStrategy, NgModule, InjectionToken, Optional, Inject } from '@angular/core';
+import * as i1$1 from '@veloce/api';
+import { ApiModule } from '@veloce/api';
+import * as i2 from '@veloce/components';
+import { LoaderModule } from '@veloce/components';
+import * as i1$2 from '@veloce/sdk/cms';
+import { PreviewModule, LauncherModule } from '@veloce/sdk/cms';
+import * as i2$1 from '@veloce/sdk/runtime';
+import { RuntimeOperation, RuntimeModule, ContextService } from '@veloce/sdk/runtime';
+import * as i1 from '@angular/router';
+import { NavigationStart, NavigationCancel, NavigationEnd, NavigationError, RouterModule } from '@angular/router';
+import { filter, map, startWith, distinctUntilChanged, shareReplay, Subject, BehaviorSubject, first as first$1, takeUntil as takeUntil$1, of, tap, switchMap, catchError, from } from 'rxjs';
+import { ConfigurationContextMode, EntityUtil } from '@veloce/core';
+import * as i5 from '@angular/forms';
+import { FormGroup, FormControl, FormsModule, ReactiveFormsModule } from '@angular/forms';
+import * as i3$1 from 'primeng/button';
+import { ButtonModule } from 'primeng/button';
+import * as i6 from 'primeng/inputtext';
+import { InputTextModule } from 'primeng/inputtext';
+import * as i4 from 'primeng/radiobutton';
+import { RadioButtonModule } from 'primeng/radiobutton';
+import { map as map$1, first, takeUntil, take, tap as tap$1, catchError as catchError$1 } from 'rxjs/operators';
+import { TooltipModule } from 'ngx-bootstrap/tooltip';
+import * as i4$1 from 'primeng/api';
+import { HttpErrorResponse } from '@angular/common/http';
+
+const VELOCE_FLOW_ROOT_ROUTE = 'VELOCE_FLOW_ROOT_ROUTE';
+
+class RouterService {
+    constructor(router) {
+        this.router = router;
+        this.loading$ = this.router.events.pipe(filter(e => e instanceof NavigationStart ||
+            e instanceof NavigationCancel ||
+            e instanceof NavigationEnd ||
+            e instanceof NavigationError), map(e => e instanceof NavigationStart), startWith(false), distinctUntilChanged());
+    }
+    getFlowRootRoute(route) {
+        var _a;
+        const path = [...route.pathFromRoot];
+        while (path.length) {
+            const parent = path.pop();
+            if (!parent) {
+                break;
+            }
+            if (((_a = parent.routeConfig) === null || _a === void 0 ? void 0 : _a.id) === VELOCE_FLOW_ROOT_ROUTE) {
+                return parent;
+            }
+        }
+        return;
+    }
+    getFlowRootPath(route) {
+        const rootRoute = this.getFlowRootRoute(route);
+        if (!rootRoute) {
+            return '';
+        }
+        const path = rootRoute.pathFromRoot
+            .map(r => { var _a; return (_a = r.routeConfig) === null || _a === void 0 ? void 0 : _a.path; })
+            .filter(Boolean)
+            .join('/');
+        return '/' + path;
+    }
+}
+RouterService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RouterService, deps: [{ token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+RouterService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RouterService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RouterService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Router }]; } });
+
+class FlowComponent {
+    constructor(routerService) {
+        this.routerService = routerService;
+    }
+}
+FlowComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FlowComponent, deps: [{ token: RouterService }], target: i0.ɵɵFactoryTarget.Component });
+FlowComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: FlowComponent, selector: "vl-flow", ngImport: i0, template: "<div class=\"loading-overlay\" *ngIf=\"routerService.loading$ | async\">\n  <vl-loader label=\"LOADING\"></vl-loader>\n</div>\n\n<router-outlet></router-outlet>\n", styles: [".loading-overlay{position:absolute;height:100%;width:100%;left:0;right:0;top:0;bottom:0;background-color:#ffffff80;z-index:4}\n"], components: [{ type: i2.LoaderComponent, selector: "vl-loader", inputs: ["label"] }], directives: [{ type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i1.RouterOutlet, selector: "router-outlet", outputs: ["activate", "deactivate"], exportAs: ["outlet"] }], pipes: { "async": i3.AsyncPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FlowComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vl-flow',
+                    templateUrl: './flow.component.html',
+                    styleUrls: ['./flow.component.scss'],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return [{ type: RouterService }]; } });
+
+class ContextGuard {
+    constructor(router, routerService) {
+        this.router = router;
+        this.routerService = routerService;
+    }
+    getConfigurationContextMode(accountId, quoteId, orderId, rpcMessage) {
+        if (accountId) {
+            return ConfigurationContextMode.ACCOUNT;
+        }
+        if (quoteId) {
+            return ConfigurationContextMode.QUOTE;
+        }
+        if (orderId) {
+            return ConfigurationContextMode.ORDER;
+        }
+        if (rpcMessage) {
+            return ConfigurationContextMode.REMOTE;
+        }
+        return;
+    }
+    checkActivation(route) {
+        var _a, _b;
+        const { queryParams } = route;
+        const { accountId, quoteId, orderId } = queryParams;
+        const rpcMessage = window['RPC_MESSAGE'];
+        const rpcMessageId = rpcMessage && ((_b = (_a = JSON.parse(rpcMessage)) === null || _a === void 0 ? void 0 : _a.quote) === null || _b === void 0 ? void 0 : _b.Id);
+        const headerId = accountId || quoteId || orderId || rpcMessageId || 'empty-for-test-mode';
+        const mode = this.getConfigurationContextMode(accountId, quoteId, orderId, rpcMessage);
+        if (mode === void 0) {
+            return this.reject(route, 'Mode is undefined');
+        }
+        const contextRouteData = {
+            headerId,
+            mode,
+        };
+        route.data = Object.assign(Object.assign({}, route.data), contextRouteData);
+        return true;
+    }
+    canActivate(route) {
+        return this.checkActivation(route);
+    }
+    canActivateChild(childRoute) {
+        return this.checkActivation(childRoute);
+    }
+    reject(route, message) {
+        const parentUrl = this.routerService.getFlowRootPath(route);
+        this.router.navigate([parentUrl, '404'], {
+            state: { message },
+        });
+        return false;
+    }
+}
+ContextGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ContextGuard, deps: [{ token: i1.Router }, { token: RouterService }], target: i0.ɵɵFactoryTarget.Injectable });
+ContextGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ContextGuard });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ContextGuard, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: RouterService }]; } });
+
+class RootGuard {
+    constructor(router, routerService) {
+        this.router = router;
+        this.routerService = routerService;
+        this.initialized = false;
+        this.navToRestore = null;
+    }
+    canActivate(route) {
+        // We always need to initialize root component first, and only then start checking guards/resolvers
+        var _a;
+        if (!this.initialized) {
+            this.initialized = true;
+            this.navToRestore = this.router.getCurrentNavigation();
+            const rootUrl = this.routerService.getFlowRootPath(route);
+            this.router.navigate([rootUrl], { replaceUrl: !((_a = this.navToRestore) === null || _a === void 0 ? void 0 : _a.previousNavigation) });
+        }
+        else if (this.navToRestore) {
+            const nav = this.navToRestore;
+            setTimeout(() => {
+                this.router.navigateByUrl(nav.extractedUrl, nav.extras);
+                this.navToRestore = null;
+            });
+        }
+        return true;
+    }
+    canDeactivate() {
+        this.initialized = false;
+        return true;
+    }
+}
+RootGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RootGuard, deps: [{ token: i1.Router }, { token: RouterService }], target: i0.ɵɵFactoryTarget.Injectable });
+RootGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RootGuard, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RootGuard, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: RouterService }]; } });
+
+class FlowService {
+    constructor(configurationSettingsApiService) {
+        this.configurationSettingsApiService = configurationSettingsApiService;
+        this.flowsKey = 'flows';
+    }
+    getFlow(id) {
+        return this.fetchFlows().pipe(map$1(flows => flows.find(flow => flow.id == id)));
+    }
+    fetchFlows() {
+        return this.configurationSettingsApiService
+            .fetchSetting(this.flowsKey)
+            .pipe(map$1(({ value }) => (value ? JSON.parse(value) : [])));
+    }
+}
+FlowService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FlowService, deps: [{ token: i1$1.ConfigurationSettingsApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+FlowService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FlowService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FlowService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1$1.ConfigurationSettingsApiService }]; } });
+
+class DebugComponent {
+    constructor(flowService, router, activatedRoute) {
+        this.flowService = flowService;
+        this.router = router;
+        this.activatedRoute = activatedRoute;
+        this.form = new FormGroup({
+            id: new FormControl(''),
+        });
+        this.flows$ = this.flowService.fetchFlows().pipe(map(flows => flows.map(flow => {
+            var _a, _b, _c;
+            const queryParams = (_b = (_a = flow === null || flow === void 0 ? void 0 : flow.properties) === null || _a === void 0 ? void 0 : _a.queryParams) !== null && _b !== void 0 ? _b : {};
+            return {
+                id: flow.id,
+                entryPath: (_c = flow === null || flow === void 0 ? void 0 : flow.properties) === null || _c === void 0 ? void 0 : _c.entryPath,
+                queryParams,
+                queryParamsStr: JSON.stringify(queryParams),
+            };
+        })), shareReplay());
+    }
+    runFlow() {
+        const { id } = this.form.value;
+        if (!id || !this.selectedFlow) {
+            return;
+        }
+        const paths = this.selectedFlow.entryPath.split('/').filter(Boolean);
+        this.router.navigate(['..', ...paths], {
+            queryParams: Object.assign({ flowId: this.selectedFlow.id, quoteId: id }, this.selectedFlow.queryParams),
+            relativeTo: this.activatedRoute,
+        });
+    }
+}
+DebugComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: DebugComponent, deps: [{ token: FlowService }, { token: i1.Router }, { token: i1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Component });
+DebugComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: DebugComponent, selector: "vl-flow-debug", ngImport: i0, template: "<form [formGroup]=\"form\">\n  <div class=\"field\">\n    <label>SF Object ID</label>\n    <input formControlName=\"id\" pInputText type=\"text\" />\n  </div>\n\n  <p-button\n    styleClass=\"p-button-primary\"\n    label=\"Run Flow\"\n    [disabled]=\"!form.value.id || !selectedFlow\"\n    (onClick)=\"runFlow()\"\n  ></p-button>\n</form>\n\n<table>\n  <thead>\n    <tr>\n      <th [width]=\"30\"></th>\n      <th [width]=\"160\">ID</th>\n      <th [width]=\"160\">Entry Path</th>\n      <th>QueryParams</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr *ngFor=\"let flow of flows$ | async\" (click)=\"selectedFlow = flow\">\n      <td><p-radioButton [inputId]=\"flow.id\" name=\"flow\" [value]=\"flow\" [(ngModel)]=\"selectedFlow\"></p-radioButton></td>\n      <td>{{ flow.id }}</td>\n      <td>{{ flow.entryPath }}</td>\n      <td>{{ flow.queryParamsStr }}</td>\n    </tr>\n  </tbody>\n</table>\n", styles: ["form{display:flex;align-items:center;justify-content:space-between}.field{display:flex;flex-direction:column;width:200px;flex-shrink:0}table{width:100%;border-collapse:collapse}tr{cursor:pointer}tr:hover{background-color:#f0f5fa}th{text-align:left;font-weight:600}th,td{padding:0 10px;height:30px;border-bottom:1px solid var(--vl-border-color);margin-right:16px}\n"], components: [{ type: i3$1.Button, selector: "p-button", inputs: ["type", "iconPos", "icon", "badge", "label", "disabled", "loading", "loadingIcon", "style", "styleClass", "badgeClass"], outputs: ["onClick", "onFocus", "onBlur"] }, { type: i4.RadioButton, selector: "p-radioButton", inputs: ["value", "formControlName", "name", "disabled", "label", "tabindex", "inputId", "ariaLabelledBy", "ariaLabel", "style", "styleClass", "labelStyleClass"], outputs: ["onClick", "onFocus", "onBlur"] }], directives: [{ type: i5.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { type: i5.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i5.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { 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.InputText, selector: "[pInputText]" }, { type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i5.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }], pipes: { "async": i3.AsyncPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: DebugComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vl-flow-debug',
+                    templateUrl: './debug.component.html',
+                    styleUrls: ['./debug.component.scss'],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return [{ type: FlowService }, { type: i1.Router }, { type: i1.ActivatedRoute }]; } });
+
+const routes$1 = [{ path: '', component: DebugComponent }];
+class DebugModule {
+}
+DebugModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: DebugModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+DebugModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: DebugModule, declarations: [DebugComponent], imports: [CommonModule,
+        FormsModule,
+        ReactiveFormsModule, i1.RouterModule, RadioButtonModule,
+        ButtonModule,
+        InputTextModule] });
+DebugModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: DebugModule, imports: [[
+            CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            RouterModule.forChild(routes$1),
+            RadioButtonModule,
+            ButtonModule,
+            InputTextModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: DebugModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [DebugComponent],
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        RouterModule.forChild(routes$1),
+                        RadioButtonModule,
+                        ButtonModule,
+                        InputTextModule,
+                    ],
+                }]
+        }] });
+
+class LegacyProductComponent {
+    constructor(route, quoteService, quoteApiService, contextService, runtimeContextService, runtimeService, currentStateService) {
+        this.route = route;
+        this.quoteService = quoteService;
+        this.quoteApiService = quoteApiService;
+        this.contextService = contextService;
+        this.runtimeContextService = runtimeContextService;
+        this.runtimeService = runtimeService;
+        this.currentStateService = currentStateService;
+        this.destroyed$ = new Subject();
+    }
+    ngOnInit() {
+        this.quoteService.quote$
+            .pipe(first(), takeUntil(this.destroyed$))
+            .subscribe(quote => this.init(quote, this.route.snapshot.queryParams));
+        this.runtimeService.onSolutionStopEvent.pipe(take(1)).subscribe(lineItem => this.onSolutionStop(lineItem));
+        this.runtimeService.onSolutionReadyEvent.pipe(take(1)).subscribe(event => this.onSolutionReady(event));
+        this.runtimeService.onSolutionCancelEvent.pipe(take(1)).subscribe(() => this.onSolutionCancel());
+    }
+    ngOnDestroy() {
+        this.destroyed$.next();
+        this.destroyed$.complete();
+    }
+    onSolutionReady(lineItem) {
+        var _a;
+        lineItem.actionCode = (_a = lineItem.actionCode) !== null && _a !== void 0 ? _a : 'ADD';
+    }
+    onSolutionCancel() {
+        this.quoteService.quote$.pipe(first(), takeUntil(this.destroyed$)).subscribe(quote => {
+            window['VELO_BACK_FN'].apply(null, [quote.quoteId]);
+        });
+    }
+    onSolutionUpdated(lineItem) {
+        const states = {
+            configurableRamp: lineItem,
+            currentState: this.currentStateService.currentState,
+            asset: this.getAsset(lineItem),
+        };
+        this.runtimeService.updateRuntime(states);
+    }
+    onSolutionStop(lineItem) {
+        this.quoteService.quote$.pipe(first(), takeUntil(this.destroyed$)).subscribe(quote => {
+            const quoteToUpsert = Object.assign(Object.assign({}, quote), { context: this.contextService.resolve(), currentState: [...(this.currentStateService.currentState || []).filter(li => li.id !== lineItem.id), lineItem] });
+            this.quoteApiService
+                .upsertQuote(quoteToUpsert)
+                .pipe(take(1))
+                .subscribe(quote => {
+                window['VELO_BACK_FN'].apply(null, [quote.quoteId]);
+            });
+        });
+    }
+    init(quote, queryParams) {
+        const productId = queryParams['productId'];
+        const lineItemId = this.getLineItemId(quote, queryParams);
+        this.assets = quote.initialState;
+        lineItemId && quote.currentState ? this.reConfigure(lineItemId, quote.currentState) : this.configure(productId);
+    }
+    getLineItemId(quote, queryParams) {
+        if (EntityUtil.isPresent(queryParams['lineItemId'])) {
+            return queryParams['lineItemId'];
+        }
+        return quote.currentState
+            .filter(lineItem => lineItem.productId === queryParams['productId'])
+            .map(lineItem => lineItem.id)
+            .find(id => id);
+    }
+    configure(productId) {
+        const runtimeContext = this.getRuntimeContext(productId, '', RuntimeOperation.INIT);
+        this.startRuntime({}, runtimeContext);
+    }
+    reConfigure(lineItemId, currentState) {
+        const currentStateItem = EntityUtil.findById(lineItemId, currentState);
+        const runtimeContext = this.getRuntimeContext(currentStateItem.productId, currentStateItem.offeringId, RuntimeOperation.UPDATE);
+        const states = {
+            configurableRamp: currentStateItem,
+            currentState,
+            asset: this.getAsset(currentStateItem),
+        };
+        this.currentStateService.update(currentState);
+        this.startRuntime(states, runtimeContext);
+    }
+    getAsset(lineItem) {
+        return this.assets && this.assets.find(a => a.id === lineItem.openOrderLineItemId || a.id === lineItem.assetId);
+    }
+    startRuntime(states, runtimeContext$) {
+        runtimeContext$
+            .pipe(take(1), map$1(runtimeContext => {
+            this.runtimeService.startRuntime(runtimeContext, states);
+        }))
+            .subscribe();
+    }
+    getRuntimeContext(productId, offeringId, runtimeOperation) {
+        return this.runtimeContextService.getRuntimeContext(productId, offeringId).pipe(map$1(runtimeContext => {
+            runtimeContext.invocationContext = { runtimeOperation: RuntimeOperation[runtimeOperation] };
+            return runtimeContext;
+        }));
+    }
+}
+LegacyProductComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: LegacyProductComponent, deps: [{ token: i1.ActivatedRoute }, { token: i2$1.QuoteService }, { token: i1$1.QuoteApiService }, { token: i2$1.ContextService }, { token: i2$1.RuntimeContextService }, { token: i2$1.RuntimeService }, { token: i2$1.CurrentStateService }], target: i0.ɵɵFactoryTarget.Component });
+LegacyProductComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: LegacyProductComponent, selector: "ng-component", ngImport: i0, template: "<vl-runtime #runtimeView (solutionUpdated)=\"onSolutionUpdated($event)\"></vl-runtime>\n", styles: [":host{display:block;height:100%}\n"], components: [{ type: i2$1.RuntimeComponent, selector: "vl-runtime", outputs: ["solutionUpdated"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: LegacyProductComponent, decorators: [{
+            type: Component,
+            args: [{
+                    templateUrl: './legacy-product.component.html',
+                    styleUrls: ['./legacy-product.component.scss'],
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ActivatedRoute }, { type: i2$1.QuoteService }, { type: i1$1.QuoteApiService }, { type: i2$1.ContextService }, { type: i2$1.RuntimeContextService }, { type: i2$1.RuntimeService }, { type: i2$1.CurrentStateService }]; } });
+
+class LegacyProductModule {
+}
+LegacyProductModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: LegacyProductModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+LegacyProductModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: LegacyProductModule, declarations: [LegacyProductComponent], imports: [CommonModule, RuntimeModule, TooltipModule], exports: [LegacyProductComponent] });
+LegacyProductModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: LegacyProductModule, imports: [[CommonModule, RuntimeModule, TooltipModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: LegacyProductModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [LegacyProductComponent],
+                    imports: [CommonModule, RuntimeModule, TooltipModule],
+                    exports: [LegacyProductComponent],
+                }]
+        }] });
+
+const FLOW_CUSTOMIZATION = new InjectionToken('FLOW_CUSTOMIZATION');
+
+class ProductComponent {
+    constructor(runtimeService, conigurationService, quoteService, route, messageService, customizationService) {
+        this.runtimeService = runtimeService;
+        this.conigurationService = conigurationService;
+        this.quoteService = quoteService;
+        this.route = route;
+        this.messageService = messageService;
+        this.customizationService = customizationService;
+        this.destroy$ = new Subject();
+        this.state$ = new BehaviorSubject({ loading: true, failure: false });
+    }
+    ngOnInit() {
+        this.quoteService.quote$
+            .pipe(first$1(), takeUntil$1(this.destroy$))
+            .subscribe(quote => this.init(quote, this.route.snapshot.queryParams));
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    customize(productId) {
+        var _a;
+        if (!((_a = this.customizationService) === null || _a === void 0 ? void 0 : _a.getUiDefinition)) {
+            return of(null);
+        }
+        return this.customizationService.getUiDefinition(productId).pipe(tap(uiDef => {
+            var _a;
+            if (uiDef) {
+                this.uiDefinition = uiDef;
+                this.runtimeService.uiDefinitionProperties = (_a = uiDef.properties) !== null && _a !== void 0 ? _a : {};
+            }
+        }));
+    }
+    init(quote, queryParams) {
+        var _a;
+        const lineItemId = this.getLineItemId(quote, queryParams);
+        const currentStateItem = EntityUtil.findById(lineItemId, quote.currentState);
+        const productId = (_a = currentStateItem === null || currentStateItem === void 0 ? void 0 : currentStateItem.productId) !== null && _a !== void 0 ? _a : queryParams['productId'];
+        const { offeringId } = currentStateItem !== null && currentStateItem !== void 0 ? currentStateItem : {};
+        if (currentStateItem) {
+            this.conigurationService.updateCurrentStates({
+                configurableRamp: currentStateItem,
+                currentState: quote.currentState,
+            });
+        }
+        this.runtimeService
+            .init({ productId, offeringId })
+            .pipe(tap(context => (this.uiDefinition = context === null || context === void 0 ? void 0 : context.uiDefinition)), switchMap(() => this.customize(productId)), switchMap(() => this.conigurationService.configure()), tap(() => this.state$.next({ loading: false, failure: false })), catchError(error => {
+            this.messageService.add({
+                severity: 'error',
+                summary: error,
+            });
+            this.state$.next({ loading: false, failure: true });
+            return of();
+        }), takeUntil$1(this.destroy$))
+            .subscribe();
+    }
+    getLineItemId(quote, queryParams) {
+        if (EntityUtil.isPresent(queryParams['lineItemId'])) {
+            return queryParams['lineItemId'];
+        }
+        return quote.currentState
+            .filter(lineItem => lineItem.productId === queryParams['productId'])
+            .map(lineItem => lineItem.id)
+            .find(id => id);
+    }
+}
+ProductComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ProductComponent, deps: [{ token: i1$2.ConfigurationRuntimeService }, { token: i1$2.ConfigurationService }, { token: i2$1.QuoteService }, { token: i1.ActivatedRoute }, { token: i4$1.MessageService }, { token: FLOW_CUSTOMIZATION, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+ProductComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: ProductComponent, selector: "vl-flow-product", ngImport: i0, template: "<ng-container *ngIf=\"state$ | async as state\">\n  <vl-loader *ngIf=\"state.loading; else content\" [label]=\"'Loading UI'\"></vl-loader>\n\n  <ng-template #content>\n    <ng-container *ngIf=\"!state.failure\">\n      <vl-cms-preview [uiDefinition]=\"uiDefinition\"></vl-cms-preview>\n    </ng-container>\n  </ng-template>\n</ng-container>\n", styles: [""], components: [{ type: i2.LoaderComponent, selector: "vl-loader", inputs: ["label"] }, { type: i1$2.PreviewComponent, selector: "vl-cms-preview", inputs: ["modelId", "uiDefinition"] }], directives: [{ type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "async": i3.AsyncPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ProductComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vl-flow-product',
+                    templateUrl: './product.component.html',
+                    styleUrls: ['./product.component.scss'],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return [{ type: i1$2.ConfigurationRuntimeService }, { type: i1$2.ConfigurationService }, { type: i2$1.QuoteService }, { type: i1.ActivatedRoute }, { type: i4$1.MessageService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [FLOW_CUSTOMIZATION]
+                }] }]; } });
+
+class ProductModule {
+}
+ProductModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ProductModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ProductModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ProductModule, declarations: [ProductComponent], imports: [CommonModule, PreviewModule, LoaderModule], exports: [ProductComponent] });
+ProductModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ProductModule, imports: [[CommonModule, PreviewModule, LoaderModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ProductModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [ProductComponent],
+                    imports: [CommonModule, PreviewModule, LoaderModule],
+                    exports: [ProductComponent],
+                }]
+        }] });
+
+class RecordNotFoundComponent {
+    constructor(router, route) {
+        var _a;
+        this.router = router;
+        this.route = route;
+        const navigation = this.router.getCurrentNavigation();
+        const { state } = (navigation === null || navigation === void 0 ? void 0 : navigation.extras) || {};
+        this.message = state === null || state === void 0 ? void 0 : state.message;
+        this.subMessage = ((_a = this.message) === null || _a === void 0 ? void 0 : _a.includes('/describe')) ? 'A potential problem with permissions' : '';
+    }
+}
+RecordNotFoundComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RecordNotFoundComponent, deps: [{ token: i1.Router }, { token: i1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Component });
+RecordNotFoundComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: RecordNotFoundComponent, selector: "vl-flow-record-not-found", ngImport: i0, template: "<div class=\"row\">\n  <div class=\"col-md-12\">\n    <div class=\"message-wrapper\">\n      <div class=\"msg\">\n        <div *ngIf=\"message; else defaultMessage\" class=\"message-title\">\n          <p>{{ message }}</p>\n\n          <p *ngIf=\"subMessage\" class=\"message-title\">{{ subMessage }}</p>\n        </div>\n\n        <ng-template #defaultMessage>Record not found</ng-template>\n      </div>\n    </div>\n  </div>\n</div>\n", directives: [{ type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RecordNotFoundComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vl-flow-record-not-found',
+                    templateUrl: './record-not-found.component.html',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i1.ActivatedRoute }]; } });
+
+const routes = [{ path: '', component: RecordNotFoundComponent }];
+class RecordNotFoundModule {
+}
+RecordNotFoundModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RecordNotFoundModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+RecordNotFoundModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RecordNotFoundModule, declarations: [RecordNotFoundComponent], imports: [CommonModule, i1.RouterModule] });
+RecordNotFoundModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RecordNotFoundModule, imports: [[CommonModule, RouterModule.forChild(routes)]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RecordNotFoundModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [RecordNotFoundComponent],
+                    imports: [CommonModule, RouterModule.forChild(routes)],
+                }]
+        }] });
+
+class ContextResolver {
+    constructor(contextService, router, routerService) {
+        this.contextService = contextService;
+        this.router = router;
+        this.routerService = routerService;
+    }
+    handleError(route, message) {
+        this.contextService.delete();
+        const parentUrl = this.routerService.getFlowRootPath(route);
+        return from(this.router.navigate([parentUrl, '404'], { state: { message } }));
+    }
+    resolve(route) {
+        const { queryParams, data } = route;
+        const { uiDefinitionId } = queryParams;
+        const { headerId, mode } = data !== null && data !== void 0 ? data : {};
+        const currentContext = this.contextService.resolve();
+        if (headerId && (currentContext === null || currentContext === void 0 ? void 0 : currentContext.headerId) === headerId) {
+            return of(currentContext);
+        }
+        return this.contextService.create(headerId, mode).pipe(tap$1((context) => {
+            this.contextService.update(Object.assign(Object.assign({}, context), { uiDefinitionId, properties: Object.assign(Object.assign(Object.assign({}, currentContext === null || currentContext === void 0 ? void 0 : currentContext.properties), context.properties), (queryParams !== null && queryParams !== void 0 ? queryParams : {})) }));
+        }), catchError$1(e => {
+            const message = e instanceof HttpErrorResponse ? e.error.message : e;
+            this.handleError(route, message);
+            return of(null);
+        }));
+    }
+}
+ContextResolver.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ContextResolver, deps: [{ token: i2$1.ContextService }, { token: i1.Router }, { token: RouterService }], target: i0.ɵɵFactoryTarget.Injectable });
+ContextResolver.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ContextResolver });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ContextResolver, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i2$1.ContextService }, { type: i1.Router }, { type: RouterService }]; } });
+
+class FlowResolver {
+    constructor(router, flowService, routerService) {
+        this.router = router;
+        this.flowService = flowService;
+        this.routerService = routerService;
+    }
+    handleError(route, message, queryParams) {
+        const parentUrl = this.routerService.getFlowRootPath(route);
+        return this.router.navigate([parentUrl, '404'], {
+            queryParams,
+            state: {
+                message: message,
+            },
+        });
+    }
+    resolve(route) {
+        const { queryParams } = route;
+        const { flowId } = queryParams;
+        if (!flowId) {
+            return this.handleError(route);
+        }
+        return this.flowService.getFlow(flowId).pipe(map$1(flow => {
+            if (!flow) {
+                return this.handleError(route, `Flow with flowId=${flowId} is not defined`);
+            }
+            const { properties } = flow;
+            const { entryPath } = properties;
+            const { queryParams: flowQueryParams } = properties;
+            const mergedParams = Object.assign(Object.assign({}, queryParams), flowQueryParams);
+            const parentUrl = this.routerService.getFlowRootPath(route);
+            const entryUrl = String(entryPath !== null && entryPath !== void 0 ? entryPath : '')
+                .split('/')
+                .filter(Boolean);
+            return this.router
+                .navigate([parentUrl, ...entryUrl], {
+                queryParams: mergedParams,
+                replaceUrl: true,
+            })
+                .catch(e => {
+                const message = e instanceof HttpErrorResponse ? e.error.message : e;
+                return this.handleError(route, message, mergedParams);
+            });
+        }));
+    }
+}
+FlowResolver.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FlowResolver, deps: [{ token: i1.Router }, { token: FlowService }, { token: RouterService }], target: i0.ɵɵFactoryTarget.Injectable });
+FlowResolver.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FlowResolver });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FlowResolver, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: FlowService }, { type: RouterService }]; } });
+
+class QuoteResolver {
+    constructor(router, quoteService, routerService) {
+        this.router = router;
+        this.quoteService = quoteService;
+        this.routerService = routerService;
+    }
+    handleError(route, message) {
+        const parentUrl = this.routerService.getFlowRootPath(route);
+        return from(this.router.navigate([parentUrl, '404'], { state: { message } }));
+    }
+    resolve(route) {
+        const { headerId } = route.data;
+        const quote = this.quoteService.getQuote();
+        if (quote && quote.quoteId === headerId) {
+            return of(true);
+        }
+        const { queryParams } = route;
+        return this.quoteService.init(headerId, queryParams).pipe(catchError(e => {
+            const message = e instanceof HttpErrorResponse ? e.error.message : e;
+            return this.handleError(route, message);
+        }));
+    }
+}
+QuoteResolver.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: QuoteResolver, deps: [{ token: i1.Router }, { token: i2$1.QuoteService }, { token: RouterService }], target: i0.ɵɵFactoryTarget.Injectable });
+QuoteResolver.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: QuoteResolver });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: QuoteResolver, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i2$1.QuoteService }, { type: RouterService }]; } });
+
+const rootRoute = {
+    id: VELOCE_FLOW_ROOT_ROUTE,
+    path: '',
+    component: FlowComponent,
+    canActivate: [RootGuard],
+    canDeactivate: [RootGuard],
+    children: [
+        {
+            path: 'flows',
+            runGuardsAndResolvers: 'paramsOrQueryParamsChange',
+            resolve: { quote: FlowResolver },
+            canActivate: [ContextGuard],
+            children: [],
+        },
+        {
+            path: 'legacy',
+            children: [
+                {
+                    path: 'product',
+                    component: LegacyProductComponent,
+                    runGuardsAndResolvers: 'paramsOrQueryParamsChange',
+                    resolve: { context: ContextResolver, quote: QuoteResolver },
+                    canActivate: [ContextGuard],
+                },
+            ],
+        },
+        {
+            path: 'product',
+            component: ProductComponent,
+            runGuardsAndResolvers: 'paramsOrQueryParamsChange',
+            resolve: { context: ContextResolver, quote: QuoteResolver },
+            canActivate: [ContextGuard],
+        },
+        {
+            path: 'debug',
+            loadChildren: () => DebugModule,
+        },
+        {
+            path: '404',
+            loadChildren: () => RecordNotFoundModule,
+        },
+    ],
+};
+class FlowRoutingModule {
+}
+FlowRoutingModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FlowRoutingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+FlowRoutingModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FlowRoutingModule, imports: [i1.RouterModule, ProductModule, LegacyProductModule], exports: [RouterModule] });
+FlowRoutingModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FlowRoutingModule, providers: [RouterService, RootGuard, ContextGuard, ContextResolver, FlowResolver, QuoteResolver], imports: [[RouterModule.forChild([rootRoute]), ProductModule, LegacyProductModule], RouterModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FlowRoutingModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [RouterModule.forChild([rootRoute]), ProductModule, LegacyProductModule],
+                    exports: [RouterModule],
+                    providers: [RouterService, RootGuard, ContextGuard, ContextResolver, FlowResolver, QuoteResolver],
+                }]
+        }] });
+
+class FlowModule {
+}
+FlowModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FlowModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+FlowModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FlowModule, declarations: [FlowComponent], imports: [CommonModule, FlowRoutingModule, ApiModule, LauncherModule, LoaderModule] });
+FlowModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FlowModule, providers: [FlowService, ContextService], imports: [[CommonModule, FlowRoutingModule, ApiModule, LauncherModule, LoaderModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FlowModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [FlowComponent],
+                    imports: [CommonModule, FlowRoutingModule, ApiModule, LauncherModule, LoaderModule],
+                    providers: [FlowService, ContextService],
+                }]
+        }] });
 
 /**
  * Generated bundle index. Do not edit.
  */
+
+export { ContextGuard, FLOW_CUSTOMIZATION, FlowModule, FlowService, VELOCE_FLOW_ROOT_ROUTE };
 //# sourceMappingURL=veloce-sdk.js.map