@veloceapps/sdk 7.0.0-8 → 7.0.1-0

package/esm2020/src/pages/remote/remote.module.mjs

@@ -0,0 +1,20 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { LoaderModule } from '@veloceapps/components';
+import { PreviewModule } from '@veloceapps/sdk/cms';
+import { RemoteComponent } from './remote.component';
+import * as i0 from "@angular/core";
+export class RemoteModule {
+}
+RemoteModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: RemoteModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+RemoteModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.8", ngImport: i0, type: RemoteModule, declarations: [RemoteComponent], imports: [CommonModule, PreviewModule, LoaderModule], exports: [RemoteComponent] });
+RemoteModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: RemoteModule, imports: [CommonModule, PreviewModule, LoaderModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: RemoteModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [RemoteComponent],
+                    imports: [CommonModule, PreviewModule, LoaderModule],
+                    exports: [RemoteComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVtb3RlLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvc2RrL3NyYy9wYWdlcy9yZW1vdGUvcmVtb3RlLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDdEQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ3BELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQzs7QUFPckQsTUFBTSxPQUFPLFlBQVk7O3lHQUFaLFlBQVk7MEdBQVosWUFBWSxpQkFKUixlQUFlLGFBQ3BCLFlBQVksRUFBRSxhQUFhLEVBQUUsWUFBWSxhQUN6QyxlQUFlOzBHQUVkLFlBQVksWUFIYixZQUFZLEVBQUUsYUFBYSxFQUFFLFlBQVk7MkZBR3hDLFlBQVk7a0JBTHhCLFFBQVE7bUJBQUM7b0JBQ1IsWUFBWSxFQUFFLENBQUMsZUFBZSxDQUFDO29CQUMvQixPQUFPLEVBQUUsQ0FBQyxZQUFZLEVBQUUsYUFBYSxFQUFFLFlBQVksQ0FBQztvQkFDcEQsT0FBTyxFQUFFLENBQUMsZUFBZSxDQUFDO2lCQUMzQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgTG9hZGVyTW9kdWxlIH0gZnJvbSAnQHZlbG9jZWFwcHMvY29tcG9uZW50cyc7XG5pbXBvcnQgeyBQcmV2aWV3TW9kdWxlIH0gZnJvbSAnQHZlbG9jZWFwcHMvc2RrL2Ntcyc7XG5pbXBvcnQgeyBSZW1vdGVDb21wb25lbnQgfSBmcm9tICcuL3JlbW90ZS5jb21wb25lbnQnO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtSZW1vdGVDb21wb25lbnRdLFxuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlLCBQcmV2aWV3TW9kdWxlLCBMb2FkZXJNb2R1bGVdLFxuICBleHBvcnRzOiBbUmVtb3RlQ29tcG9uZW50XSxcbn0pXG5leHBvcnQgY2xhc3MgUmVtb3RlTW9kdWxlIHt9XG4iXX0=

package/esm2020/src/pages/shopping-cart/shopping-cart.component.mjs

@@ -0,0 +1,111 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Inject, Optional, } from '@angular/core';
+import { UITemplatesApiService } from '@veloceapps/api';
+import { ToastService, ToastType } from '@veloceapps/components';
+import { UITemplateComponentType } from '@veloceapps/core';
+import { ContextService } from '@veloceapps/sdk/core';
+import { BehaviorSubject, catchError, map, of, Subject, switchMap, takeUntil, tap } from 'rxjs';
+import { FLOW_CUSTOMIZATION } from '../../types';
+import * as i0 from "@angular/core";
+import * as i1 from "@veloceapps/api";
+import * as i2 from "@veloceapps/sdk/core";
+import * as i3 from "@veloceapps/components";
+import * as i4 from "@angular/common";
+import * as i5 from "@veloceapps/sdk/cms";
+export class ShoppingCartComponent {
+    constructor(templatesApi, contextService, cdr, toastService, customizationService) {
+        this.templatesApi = templatesApi;
+        this.contextService = contextService;
+        this.cdr = cdr;
+        this.toastService = toastService;
+        this.customizationService = customizationService;
+        this.uiDefinition = undefined;
+        this.state$ = new BehaviorSubject({ loading: true, failure: false });
+        this.templateApiName = '';
+        this.destroyed$ = new Subject();
+        this.templateApiName = this.contextService.resolve().properties.cartTemplateApiName ?? '';
+    }
+    ngOnInit() {
+        this.generateUIDefinition$()
+            .pipe(tap(uiDef => {
+            if (!uiDef) {
+                throw new Error(`Component with name '${this.templateApiName}' not found.`);
+            }
+            this.uiDefinition = uiDef;
+            this.state$.next({ loading: false, failure: false });
+        }), catchError(err => {
+            const message = 'Failed to resolve Shopping cart component. ' + (err.message ?? '');
+            this.toastService.add({ severity: ToastType.error, summary: message, sticky: true });
+            this.uiDefinition = undefined;
+            this.state$.next({ loading: false, failure: true });
+            return of();
+        }), takeUntil(this.destroyed$))
+            .subscribe(() => this.cdr.detectChanges());
+    }
+    ngOnDestroy() {
+        this.destroyed$.next();
+        this.destroyed$.complete();
+    }
+    getTemplateRootComponent$(template) {
+        return this.templatesApi
+            .fetchComponents$(template.id)
+            .pipe(map(components => components.find(c => c.type === UITemplateComponentType.ROOT) ?? undefined));
+    }
+    getLocalShoppingCartComponentMeta$() {
+        if (!this.customizationService?.getShoppingCartComponent) {
+            return of(undefined);
+        }
+        return this.customizationService?.getShoppingCartComponent(this.templateApiName).pipe(map(component => {
+            if (!component) {
+                return;
+            }
+            return {
+                html: component.html,
+                css: component.css,
+                js: component.js,
+                json: component.json,
+            };
+        }));
+    }
+    getShoppingCartComponentMeta$() {
+        return this.templatesApi.fetchTemplates$().pipe(map(templates => templates.find(template => template.name === this.templateApiName)), switchMap(template => (template ? this.getTemplateRootComponent$(template) : of(undefined))), switchMap(component => component ? this.templatesApi.fetchComponentAttachments$(component.uiTemplateId, component) : of(undefined)));
+    }
+    generateUIDefinition$() {
+        return of(undefined).pipe(tap(() => {
+            if (!this.templateApiName) {
+                throw new Error("Flow Query parameter 'cartTemplateApiName' is missing.");
+            }
+        }), switchMap(() => this.getLocalShoppingCartComponentMeta$()), switchMap(meta => (meta ? of(meta) : this.getShoppingCartComponentMeta$())), map(meta => {
+            if (!meta) {
+                return;
+            }
+            const uiDef = {
+                name: '',
+                createdTimestamp: 0,
+                primary: true,
+                type: 'DEFAULT',
+                version: 2,
+                children: [
+                    {
+                        children: [],
+                        template: meta.html && btoa(meta.html),
+                        script: meta.js && btoa(meta.js),
+                        styles: meta.css && btoa(meta.css),
+                    },
+                ],
+            };
+            return uiDef;
+        }));
+    }
+}
+ShoppingCartComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ShoppingCartComponent, deps: [{ token: i1.UITemplatesApiService }, { token: i2.ContextService }, { token: i0.ChangeDetectorRef }, { token: i3.ToastService }, { token: FLOW_CUSTOMIZATION, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+ShoppingCartComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.8", type: ShoppingCartComponent, selector: "vl-flow-shopping-cart", 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: [""], dependencies: [{ kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i5.PreviewComponent, selector: "vl-cms-preview", inputs: ["modelId", "uiDefinition", "config"] }, { kind: "component", type: i3.LoaderComponent, selector: "vl-loader", inputs: ["label", "overlayVisible"] }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ShoppingCartComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'vl-flow-shopping-cart', changeDetection: ChangeDetectionStrategy.OnPush, 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" }]
+        }], ctorParameters: function () { return [{ type: i1.UITemplatesApiService }, { type: i2.ContextService }, { type: i0.ChangeDetectorRef }, { type: i3.ToastService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [FLOW_CUSTOMIZATION]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shopping-cart.component.js","sourceRoot":"","sources":["../../../../../../../libs/sdk/src/pages/shopping-cart/shopping-cart.component.ts","../../../../../../../libs/sdk/src/pages/shopping-cart/shopping-cart.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  Inject,\n  OnDestroy,\n  OnInit,\n  Optional,\n} from '@angular/core';\nimport { UITemplatesApiService } from '@veloceapps/api';\nimport { ToastService, ToastType } from '@veloceapps/components';\nimport { ComponentAttachments, TemplateComponent, UITemplate, UITemplateComponentType } from '@veloceapps/core';\nimport { ContextService, UIDefinition } from '@veloceapps/sdk/core';\nimport { BehaviorSubject, catchError, map, Observable, of, Subject, switchMap, takeUntil, tap } from 'rxjs';\nimport { FlowCustomization, FLOW_CUSTOMIZATION } from '../../types';\n\ninterface State {\n  loading: boolean;\n  failure: boolean;\n}\n\n@Component({\n  selector: 'vl-flow-shopping-cart',\n  templateUrl: './shopping-cart.component.html',\n  styleUrls: ['./shopping-cart.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class ShoppingCartComponent implements OnInit, OnDestroy {\n  public uiDefinition?: UIDefinition = undefined;\n  public state$ = new BehaviorSubject<State>({ loading: true, failure: false });\n\n  private templateApiName = '';\n  private destroyed$ = new Subject<void>();\n\n  constructor(\n    private templatesApi: UITemplatesApiService,\n    private contextService: ContextService,\n    private cdr: ChangeDetectorRef,\n    private toastService: ToastService,\n    @Optional() @Inject(FLOW_CUSTOMIZATION) private customizationService?: FlowCustomization,\n  ) {\n    this.templateApiName = this.contextService.resolve().properties.cartTemplateApiName ?? '';\n  }\n\n  public ngOnInit(): void {\n    this.generateUIDefinition$()\n      .pipe(\n        tap(uiDef => {\n          if (!uiDef) {\n            throw new Error(`Component with name '${this.templateApiName}' not found.`);\n          }\n\n          this.uiDefinition = uiDef;\n          this.state$.next({ loading: false, failure: false });\n        }),\n        catchError(err => {\n          const message = 'Failed to resolve Shopping cart component. ' + (err.message ?? '');\n          this.toastService.add({ severity: ToastType.error, summary: message, sticky: true });\n\n          this.uiDefinition = undefined;\n          this.state$.next({ loading: false, failure: true });\n          return of();\n        }),\n        takeUntil(this.destroyed$),\n      )\n      .subscribe(() => this.cdr.detectChanges());\n  }\n\n  public ngOnDestroy(): void {\n    this.destroyed$.next();\n    this.destroyed$.complete();\n  }\n\n  private getTemplateRootComponent$(template: UITemplate): Observable<TemplateComponent | undefined> {\n    return this.templatesApi\n      .fetchComponents$(template.id)\n      .pipe(map(components => components.find(c => c.type === UITemplateComponentType.ROOT) ?? undefined));\n  }\n\n  private getLocalShoppingCartComponentMeta$(): Observable<ComponentAttachments | undefined> {\n    if (!this.customizationService?.getShoppingCartComponent) {\n      return of(undefined);\n    }\n\n    return this.customizationService?.getShoppingCartComponent(this.templateApiName).pipe(\n      map(component => {\n        if (!component) {\n          return;\n        }\n\n        return <ComponentAttachments>{\n          html: component.html,\n          css: component.css,\n          js: component.js,\n          json: component.json,\n        };\n      }),\n    );\n  }\n\n  private getShoppingCartComponentMeta$(): Observable<ComponentAttachments | undefined> {\n    return this.templatesApi.fetchTemplates$().pipe(\n      map<UITemplate[], UITemplate | undefined>(templates =>\n        templates.find(template => template.name === this.templateApiName),\n      ),\n      switchMap(template => (template ? this.getTemplateRootComponent$(template) : of(undefined))),\n      switchMap(component =>\n        component ? this.templatesApi.fetchComponentAttachments$(component.uiTemplateId, component) : of(undefined),\n      ),\n    );\n  }\n\n  private generateUIDefinition$(): Observable<UIDefinition | undefined> {\n    return of(undefined).pipe(\n      tap(() => {\n        if (!this.templateApiName) {\n          throw new Error(\"Flow Query parameter 'cartTemplateApiName' is missing.\");\n        }\n      }),\n      switchMap(() => this.getLocalShoppingCartComponentMeta$()),\n      switchMap(meta => (meta ? of(meta) : this.getShoppingCartComponentMeta$())),\n      map(meta => {\n        if (!meta) {\n          return;\n        }\n\n        const uiDef: UIDefinition = {\n          name: '',\n          createdTimestamp: 0,\n          primary: true,\n          type: 'DEFAULT',\n          version: 2,\n          children: [\n            {\n              children: [],\n              template: meta.html && btoa(meta.html),\n              script: meta.js && btoa(meta.js),\n              styles: meta.css && btoa(meta.css),\n            },\n          ],\n        };\n\n        return uiDef;\n      }),\n    );\n  }\n}\n","<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"]}

package/esm2020/src/pages/shopping-cart/shopping-cart.module.mjs

@@ -0,0 +1,20 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { LoaderModule } from '@veloceapps/components';
+import { PreviewModule } from '@veloceapps/sdk/cms';
+import { ShoppingCartComponent } from './shopping-cart.component';
+import * as i0 from "@angular/core";
+export class ShoppingCartModule {
+}
+ShoppingCartModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ShoppingCartModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ShoppingCartModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.8", ngImport: i0, type: ShoppingCartModule, declarations: [ShoppingCartComponent], imports: [CommonModule, PreviewModule, LoaderModule], exports: [ShoppingCartComponent] });
+ShoppingCartModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ShoppingCartModule, imports: [CommonModule, PreviewModule, LoaderModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ShoppingCartModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [ShoppingCartComponent],
+                    imports: [CommonModule, PreviewModule, LoaderModule],
+                    exports: [ShoppingCartComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hvcHBpbmctY2FydC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3Nkay9zcmMvcGFnZXMvc2hvcHBpbmctY2FydC9zaG9wcGluZy1jYXJ0Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDdEQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ3BELE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDJCQUEyQixDQUFDOztBQU9sRSxNQUFNLE9BQU8sa0JBQWtCOzsrR0FBbEIsa0JBQWtCO2dIQUFsQixrQkFBa0IsaUJBSmQscUJBQXFCLGFBQzFCLFlBQVksRUFBRSxhQUFhLEVBQUUsWUFBWSxhQUN6QyxxQkFBcUI7Z0hBRXBCLGtCQUFrQixZQUhuQixZQUFZLEVBQUUsYUFBYSxFQUFFLFlBQVk7MkZBR3hDLGtCQUFrQjtrQkFMOUIsUUFBUTttQkFBQztvQkFDUixZQUFZLEVBQUUsQ0FBQyxxQkFBcUIsQ0FBQztvQkFDckMsT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLGFBQWEsRUFBRSxZQUFZLENBQUM7b0JBQ3BELE9BQU8sRUFBRSxDQUFDLHFCQUFxQixDQUFDO2lCQUNqQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgTG9hZGVyTW9kdWxlIH0gZnJvbSAnQHZlbG9jZWFwcHMvY29tcG9uZW50cyc7XG5pbXBvcnQgeyBQcmV2aWV3TW9kdWxlIH0gZnJvbSAnQHZlbG9jZWFwcHMvc2RrL2Ntcyc7XG5pbXBvcnQgeyBTaG9wcGluZ0NhcnRDb21wb25lbnQgfSBmcm9tICcuL3Nob3BwaW5nLWNhcnQuY29tcG9uZW50JztcblxuQE5nTW9kdWxlKHtcbiAgZGVjbGFyYXRpb25zOiBbU2hvcHBpbmdDYXJ0Q29tcG9uZW50XSxcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZSwgUHJldmlld01vZHVsZSwgTG9hZGVyTW9kdWxlXSxcbiAgZXhwb3J0czogW1Nob3BwaW5nQ2FydENvbXBvbmVudF0sXG59KVxuZXhwb3J0IGNsYXNzIFNob3BwaW5nQ2FydE1vZHVsZSB7fVxuIl19

package/esm2020/src/resolvers/flow.resolver.mjs

@@ -0,0 +1,70 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import { FlowsApiService } from '@veloceapps/api';
+import { ContextService } from '@veloceapps/sdk/core';
+import { map } from 'rxjs/operators';
+import { FlowRouterService } from '../services/flow-router.service';
+import { getDefaultProperties } from '../utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@veloceapps/api";
+import * as i3 from "../services/flow-router.service";
+import * as i4 from "@veloceapps/sdk/core";
+export class FlowResolver {
+    constructor(router, flowsApiService, routerService, contextService) {
+        this.router = router;
+        this.flowsApiService = flowsApiService;
+        this.routerService = routerService;
+        this.contextService = contextService;
+    }
+    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.flowsApiService.getFlow(flowId).pipe(map(flow => {
+            if (!flow) {
+                return this.handleError(route, `Flow with flowId=${flowId} is not defined`);
+            }
+            const { properties } = flow;
+            const { queryParams: flowQueryParams, entryPath } = properties;
+            const mergedParams = {
+                ...queryParams,
+                ...flowQueryParams,
+                ...getDefaultProperties({ flowParams: properties }),
+            };
+            const contextProperties = Object.entries(mergedParams).reduce((trunk, [key, value]) => ({ ...trunk, [key]: String(value) }), {});
+            this.contextService.update({ properties: contextProperties });
+            const parentUrl = this.routerService.getFlowRootPath(route);
+            const entryUrl = String(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: "15.2.8", ngImport: i0, type: FlowResolver, deps: [{ token: i1.Router }, { token: i2.FlowsApiService }, { token: i3.FlowRouterService }, { token: i4.ContextService }], target: i0.ɵɵFactoryTarget.Injectable });
+FlowResolver.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: FlowResolver });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: FlowResolver, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i2.FlowsApiService }, { type: i3.FlowRouterService }, { type: i4.ContextService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmxvdy5yZXNvbHZlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvc2RrL3NyYy9yZXNvbHZlcnMvZmxvdy5yZXNvbHZlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN6RCxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBbUMsTUFBTSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDMUUsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQ2xELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUV0RCxPQUFPLEVBQUUsR0FBRyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDckMsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDcEUsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sVUFBVSxDQUFDOzs7Ozs7QUFHaEQsTUFBTSxPQUFPLFlBQVk7SUFDdkIsWUFDVSxNQUFjLEVBQ2QsZUFBZ0MsRUFDaEMsYUFBZ0MsRUFDaEMsY0FBOEI7UUFIOUIsV0FBTSxHQUFOLE1BQU0sQ0FBUTtRQUNkLG9CQUFlLEdBQWYsZUFBZSxDQUFpQjtRQUNoQyxrQkFBYSxHQUFiLGFBQWEsQ0FBbUI7UUFDaEMsbUJBQWMsR0FBZCxjQUFjLENBQWdCO0lBQ3JDLENBQUM7SUFFSSxXQUFXLENBQ2pCLEtBQTZCLEVBQzdCLE9BQWdCLEVBQ2hCLFdBQTZCO1FBRTdCLE1BQU0sU0FBUyxHQUFHLElBQUksQ0FBQyxhQUFhLENBQUMsZUFBZSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQzVELE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQyxTQUFTLEVBQUUsS0FBSyxDQUFDLEVBQUU7WUFDOUMsV0FBVztZQUNYLEtBQUssRUFBRTtnQkFDTCxPQUFPLEVBQUUsT0FBTzthQUNqQjtTQUNGLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFTSxPQUFPLENBQUMsS0FBNkI7UUFDMUMsTUFBTSxFQUFFLFdBQVcsRUFBRSxHQUFHLEtBQUssQ0FBQztRQUM5QixNQUFNLEVBQUUsTUFBTSxFQUFFLEdBQUcsV0FBVyxDQUFDO1FBRS9CLElBQUksQ0FBQyxNQUFNLEVBQUU7WUFDWCxPQUFPLElBQUksQ0FBQyxXQUFXLENBQUMsS0FBSyxDQUFDLENBQUM7U0FDaEM7UUFFRCxPQUFPLElBQUksQ0FBQyxlQUFlLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDLElBQUksQ0FDOUMsR0FBRyxDQUFDLElBQUksQ0FBQyxFQUFFO1lBQ1QsSUFBSSxDQUFDLElBQUksRUFBRTtnQkFDVCxPQUFPLElBQUksQ0FBQyxXQUFXLENBQUMsS0FBSyxFQUFFLG9CQUFvQixNQUFNLGlCQUFpQixDQUFDLENBQUM7YUFDN0U7WUFFRCxNQUFNLEVBQUUsVUFBVSxFQUFFLEdBQUcsSUFBSSxDQUFDO1lBQzVCLE1BQU0sRUFBRSxXQUFXLEVBQUUsZUFBZSxFQUFFLFNBQVMsRUFBRSxHQUFHLFVBQVUsQ0FBQztZQUMvRCxNQUFNLFlBQVksR0FBRztnQkFDbkIsR0FBRyxXQUFXO2dCQUNkLEdBQUcsZUFBZTtnQkFDbEIsR0FBRyxvQkFBb0IsQ0FBQyxFQUFFLFVBQVUsRUFBRSxVQUFVLEVBQUUsQ0FBQzthQUNwRCxDQUFDO1lBRUYsTUFBTSxpQkFBaUIsR0FBRyxNQUFNLENBQUMsT0FBTyxDQUFDLFlBQVksQ0FBQyxDQUFDLE1BQU0sQ0FDM0QsQ0FBQyxLQUFLLEVBQUUsQ0FBQyxHQUFHLEVBQUUsS0FBSyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsRUFBRSxHQUFHLEtBQUssRUFBRSxDQUFDLEdBQUcsQ0FBQyxFQUFFLE1BQU0sQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDLEVBQzdELEVBQUUsQ0FDSCxDQUFDO1lBRUYsSUFBSSxDQUFDLGNBQWMsQ0FBQyxNQUFNLENBQUMsRUFBRSxVQUFVLEVBQUUsaUJBQWlCLEVBQUUsQ0FBQyxDQUFDO1lBRTlELE1BQU0sU0FBUyxHQUFHLElBQUksQ0FBQyxhQUFhLENBQUMsZUFBZSxDQUFDLEtBQUssQ0FBQyxDQUFDO1lBQzVELE1BQU0sUUFBUSxHQUFHLE1BQU0sQ0FBQyxTQUFTLElBQUksRUFBRSxDQUFDO2lCQUNyQyxLQUFLLENBQUMsR0FBRyxDQUFDO2lCQUNWLE1BQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQztZQUVuQixPQUFPLElBQUksQ0FBQyxNQUFNO2lCQUNmLFFBQVEsQ0FBQyxDQUFDLFNBQVMsRUFBRSxHQUFHLFFBQVEsQ0FBQyxFQUFFO2dCQUNsQyxXQUFXLEVBQUUsWUFBWTtnQkFDekIsVUFBVSxFQUFFLElBQUk7YUFDakIsQ0FBQztpQkFDRCxLQUFLLENBQUMsQ0FBQyxDQUFDLEVBQUU7Z0JBQ1QsTUFBTSxPQUFPLEdBQUcsQ0FBQyxZQUFZLGlCQUFpQixDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO2dCQUNyRSxPQUFPLElBQUksQ0FBQyxXQUFXLENBQUMsS0FBSyxFQUFFLE9BQU8sRUFBRSxZQUFZLENBQUMsQ0FBQztZQUN4RCxDQUFDLENBQUMsQ0FBQztRQUNQLENBQUMsQ0FBQyxDQUNILENBQUM7SUFDSixDQUFDOzt5R0FuRVUsWUFBWTs2R0FBWixZQUFZOzJGQUFaLFlBQVk7a0JBRHhCLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBIdHRwRXJyb3JSZXNwb25zZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcbmltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEFjdGl2YXRlZFJvdXRlU25hcHNob3QsIFJlc29sdmUsIFJvdXRlciB9IGZyb20gJ0Bhbmd1bGFyL3JvdXRlcic7XG5pbXBvcnQgeyBGbG93c0FwaVNlcnZpY2UgfSBmcm9tICdAdmVsb2NlYXBwcy9hcGknO1xuaW1wb3J0IHsgQ29udGV4dFNlcnZpY2UgfSBmcm9tICdAdmVsb2NlYXBwcy9zZGsvY29yZSc7XG5pbXBvcnQgeyBEaWN0aW9uYXJ5IH0gZnJvbSAnbG9kYXNoJztcbmltcG9ydCB7IG1hcCB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcbmltcG9ydCB7IEZsb3dSb3V0ZXJTZXJ2aWNlIH0gZnJvbSAnLi4vc2VydmljZXMvZmxvdy1yb3V0ZXIuc2VydmljZSc7XG5pbXBvcnQgeyBnZXREZWZhdWx0UHJvcGVydGllcyB9IGZyb20gJy4uL3V0aWxzJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIEZsb3dSZXNvbHZlciBpbXBsZW1lbnRzIFJlc29sdmU8UHJvbWlzZTxib29sZWFuPj4ge1xuICBjb25zdHJ1Y3RvcihcbiAgICBwcml2YXRlIHJvdXRlcjogUm91dGVyLFxuICAgIHByaXZhdGUgZmxvd3NBcGlTZXJ2aWNlOiBGbG93c0FwaVNlcnZpY2UsXG4gICAgcHJpdmF0ZSByb3V0ZXJTZXJ2aWNlOiBGbG93Um91dGVyU2VydmljZSxcbiAgICBwcml2YXRlIGNvbnRleHRTZXJ2aWNlOiBDb250ZXh0U2VydmljZSxcbiAgKSB7fVxuXG4gIHByaXZhdGUgaGFuZGxlRXJyb3IoXG4gICAgcm91dGU6IEFjdGl2YXRlZFJvdXRlU25hcHNob3QsXG4gICAgbWVzc2FnZT86IHN0cmluZyxcbiAgICBxdWVyeVBhcmFtcz86IERpY3Rpb25hcnk8YW55PixcbiAgKTogUHJvbWlzZTxib29sZWFuPiB7XG4gICAgY29uc3QgcGFyZW50VXJsID0gdGhpcy5yb3V0ZXJTZXJ2aWNlLmdldEZsb3dSb290UGF0aChyb3V0ZSk7XG4gICAgcmV0dXJuIHRoaXMucm91dGVyLm5hdmlnYXRlKFtwYXJlbnRVcmwsICc0MDQnXSwge1xuICAgICAgcXVlcnlQYXJhbXMsXG4gICAgICBzdGF0ZToge1xuICAgICAgICBtZXNzYWdlOiBtZXNzYWdlLFxuICAgICAgfSxcbiAgICB9KTtcbiAgfVxuXG4gIHB1YmxpYyByZXNvbHZlKHJvdXRlOiBBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90KTogYW55IHtcbiAgICBjb25zdCB7IHF1ZXJ5UGFyYW1zIH0gPSByb3V0ZTtcbiAgICBjb25zdCB7IGZsb3dJZCB9ID0gcXVlcnlQYXJhbXM7XG5cbiAgICBpZiAoIWZsb3dJZCkge1xuICAgICAgcmV0dXJuIHRoaXMuaGFuZGxlRXJyb3Iocm91dGUpO1xuICAgIH1cblxuICAgIHJldHVybiB0aGlzLmZsb3dzQXBpU2VydmljZS5nZXRGbG93KGZsb3dJZCkucGlwZShcbiAgICAgIG1hcChmbG93ID0+IHtcbiAgICAgICAgaWYgKCFmbG93KSB7XG4gICAgICAgICAgcmV0dXJuIHRoaXMuaGFuZGxlRXJyb3Iocm91dGUsIGBGbG93IHdpdGggZmxvd0lkPSR7Zmxvd0lkfSBpcyBub3QgZGVmaW5lZGApO1xuICAgICAgICB9XG5cbiAgICAgICAgY29uc3QgeyBwcm9wZXJ0aWVzIH0gPSBmbG93O1xuICAgICAgICBjb25zdCB7IHF1ZXJ5UGFyYW1zOiBmbG93UXVlcnlQYXJhbXMsIGVudHJ5UGF0aCB9ID0gcHJvcGVydGllcztcbiAgICAgICAgY29uc3QgbWVyZ2VkUGFyYW1zID0ge1xuICAgICAgICAgIC4uLnF1ZXJ5UGFyYW1zLFxuICAgICAgICAgIC4uLmZsb3dRdWVyeVBhcmFtcyxcbiAgICAgICAgICAuLi5nZXREZWZhdWx0UHJvcGVydGllcyh7IGZsb3dQYXJhbXM6IHByb3BlcnRpZXMgfSksXG4gICAgICAgIH07XG5cbiAgICAgICAgY29uc3QgY29udGV4dFByb3BlcnRpZXMgPSBPYmplY3QuZW50cmllcyhtZXJnZWRQYXJhbXMpLnJlZHVjZTxEaWN0aW9uYXJ5PHN0cmluZz4+KFxuICAgICAgICAgICh0cnVuaywgW2tleSwgdmFsdWVdKSA9PiAoeyAuLi50cnVuaywgW2tleV06IFN0cmluZyh2YWx1ZSkgfSksXG4gICAgICAgICAge30sXG4gICAgICAgICk7XG5cbiAgICAgICAgdGhpcy5jb250ZXh0U2VydmljZS51cGRhdGUoeyBwcm9wZXJ0aWVzOiBjb250ZXh0UHJvcGVydGllcyB9KTtcblxuICAgICAgICBjb25zdCBwYXJlbnRVcmwgPSB0aGlzLnJvdXRlclNlcnZpY2UuZ2V0Rmxvd1Jvb3RQYXRoKHJvdXRlKTtcbiAgICAgICAgY29uc3QgZW50cnlVcmwgPSBTdHJpbmcoZW50cnlQYXRoID8/ICcnKVxuICAgICAgICAgIC5zcGxpdCgnLycpXG4gICAgICAgICAgLmZpbHRlcihCb29sZWFuKTtcblxuICAgICAgICByZXR1cm4gdGhpcy5yb3V0ZXJcbiAgICAgICAgICAubmF2aWdhdGUoW3BhcmVudFVybCwgLi4uZW50cnlVcmxdLCB7XG4gICAgICAgICAgICBxdWVyeVBhcmFtczogbWVyZ2VkUGFyYW1zLFxuICAgICAgICAgICAgcmVwbGFjZVVybDogdHJ1ZSxcbiAgICAgICAgICB9KVxuICAgICAgICAgIC5jYXRjaChlID0+IHtcbiAgICAgICAgICAgIGNvbnN0IG1lc3NhZ2UgPSBlIGluc3RhbmNlb2YgSHR0cEVycm9yUmVzcG9uc2UgPyBlLmVycm9yLm1lc3NhZ2UgOiBlO1xuICAgICAgICAgICAgcmV0dXJuIHRoaXMuaGFuZGxlRXJyb3Iocm91dGUsIG1lc3NhZ2UsIG1lcmdlZFBhcmFtcyk7XG4gICAgICAgICAgfSk7XG4gICAgICB9KSxcbiAgICApO1xuICB9XG59XG4iXX0=

package/esm2020/src/resolvers/quote.resolver.mjs

@@ -0,0 +1,90 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import { ConfigurationContextMode } from '@veloceapps/core';
+import { IntegrationState } from '@veloceapps/sdk/cms';
+import { ContextService, FlowConfigurationService, QuoteDraftService, generateModifiedAssetsMap, } from '@veloceapps/sdk/core';
+import { catchError, from, of, switchMap, tap } from 'rxjs';
+import { FlowRouterService } from '../services/flow-router.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@veloceapps/sdk/core";
+import * as i3 from "../services/flow-router.service";
+import * as i4 from "@veloceapps/sdk/cms";
+export class QuoteResolver {
+    constructor(router, quoteDraftService, routerService, contextService, flowConfiguration, integrationState) {
+        this.router = router;
+        this.quoteDraftService = quoteDraftService;
+        this.routerService = routerService;
+        this.contextService = contextService;
+        this.flowConfiguration = flowConfiguration;
+        this.integrationState = integrationState;
+    }
+    handleError(route, message) {
+        const parentUrl = this.routerService.getFlowRootPath(route);
+        return from(this.router.navigate([parentUrl, '404'], { state: { message } }));
+    }
+    calculate$() {
+        const quoteDraft = this.quoteDraftService.quoteDraft;
+        if (!this.quoteDraftService.isStandalone && quoteDraft && !this.accountHasNotAssets()) {
+            return this.flowConfiguration.calculate$(quoteDraft);
+        }
+        return of(undefined);
+    }
+    resolve(route) {
+        const { headerId } = this.contextService.resolve();
+        const quote = this.quoteDraftService.quoteDraft;
+        if (quote && quote.quoteId === headerId) {
+            return of(true);
+        }
+        const queryParams = route.queryParams;
+        return this.quoteDraftService.init(headerId, queryParams).pipe(switchMap(() => this.calculate$()), tap(() => {
+            if (!this.quoteDraftService.isStandalone && queryParams.suppressInitialNavigation !== 'true') {
+                if (this.shouldNavigateToAssets()) {
+                    this.changeNavigation('/assets', route);
+                }
+                else if (!this.quoteDraftService.isInitialized && this.quoteDraftService.hasProducts) {
+                    this.changeNavigation('/cart', route);
+                }
+            }
+            this.initializeModifiedAssetsMap();
+            this.quoteDraftService.isInitialized = true;
+            this.quoteDraftService.hasUnsavedChanges = false;
+        }), catchError(e => {
+            const message = e instanceof HttpErrorResponse ? e.error.message : e;
+            return this.handleError(route, message);
+        }));
+    }
+    changeNavigation(path, route) {
+        const parentUrl = this.routerService.getFlowRootPath(route);
+        this.router
+            .navigate([parentUrl + path], {
+            queryParams: route.queryParams,
+            replaceUrl: true,
+        })
+            .catch(e => {
+            const message = e instanceof HttpErrorResponse ? e.error.message : e;
+            return this.handleError(route, message);
+        });
+    }
+    shouldNavigateToAssets() {
+        if (this.contextService.mode === ConfigurationContextMode.ACCOUNT) {
+            return true;
+        }
+        return this.quoteDraftService.quoteDraft?.currentState.some(li => !!li.assetId) ?? false;
+    }
+    accountHasNotAssets() {
+        return this.contextService.mode === ConfigurationContextMode.ACCOUNT && !this.quoteDraftService.hasProducts;
+    }
+    initializeModifiedAssetsMap() {
+        this.integrationState.patchState({
+            modifiedAssets: generateModifiedAssetsMap(this.quoteDraftService.currentState),
+        });
+    }
+}
+QuoteResolver.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: QuoteResolver, deps: [{ token: i1.Router }, { token: i2.QuoteDraftService }, { token: i3.FlowRouterService }, { token: i2.ContextService }, { token: i2.FlowConfigurationService }, { token: i4.IntegrationState }], target: i0.ɵɵFactoryTarget.Injectable });
+QuoteResolver.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: QuoteResolver });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: QuoteResolver, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i2.QuoteDraftService }, { type: i3.FlowRouterService }, { type: i2.ContextService }, { type: i2.FlowConfigurationService }, { type: i4.IntegrationState }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quote.resolver.js","sourceRoot":"","sources":["../../../../../../libs/sdk/src/resolvers/quote.resolver.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpErrorResponse } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { ActivatedRouteSnapshot, Resolve, Router } from '@angular/router';\nimport { ConfigurationContextMode, FlowRouteParams } from '@veloceapps/core';\nimport { IntegrationState } from '@veloceapps/sdk/cms';\nimport {\n  ContextService,\n  FlowConfigurationService,\n  QuoteDraftService,\n  generateModifiedAssetsMap,\n} from '@veloceapps/sdk/core';\nimport { Observable, catchError, from, of, switchMap, tap } from 'rxjs';\nimport { FlowRouterService } from '../services/flow-router.service';\n\n@Injectable()\nexport class QuoteResolver implements Resolve<void | boolean> {\n  constructor(\n    private router: Router,\n    private quoteDraftService: QuoteDraftService,\n    private routerService: FlowRouterService,\n    private contextService: ContextService,\n    private flowConfiguration: FlowConfigurationService,\n    private integrationState: IntegrationState,\n  ) {}\n\n  private handleError(route: ActivatedRouteSnapshot, message: string): Observable<boolean> {\n    const parentUrl = this.routerService.getFlowRootPath(route);\n    return from(this.router.navigate([parentUrl, '404'], { state: { message } }));\n  }\n\n  private calculate$(): Observable<void> {\n    const quoteDraft = this.quoteDraftService.quoteDraft;\n\n    if (!this.quoteDraftService.isStandalone && quoteDraft && !this.accountHasNotAssets()) {\n      return this.flowConfiguration.calculate$(quoteDraft);\n    }\n\n    return of(undefined);\n  }\n\n  public resolve(route: ActivatedRouteSnapshot): Observable<void | boolean> {\n    const { headerId } = this.contextService.resolve();\n    const quote = this.quoteDraftService.quoteDraft;\n\n    if (quote && quote.quoteId === headerId) {\n      return of(true);\n    }\n\n    const queryParams = route.queryParams as FlowRouteParams;\n\n    return this.quoteDraftService.init(headerId, queryParams).pipe(\n      switchMap(() => this.calculate$()),\n      tap(() => {\n        if (!this.quoteDraftService.isStandalone && queryParams.suppressInitialNavigation !== 'true') {\n          if (this.shouldNavigateToAssets()) {\n            this.changeNavigation('/assets', route);\n          } else if (!this.quoteDraftService.isInitialized && this.quoteDraftService.hasProducts) {\n            this.changeNavigation('/cart', route);\n          }\n        }\n\n        this.initializeModifiedAssetsMap();\n        this.quoteDraftService.isInitialized = true;\n        this.quoteDraftService.hasUnsavedChanges = false;\n      }),\n      catchError(e => {\n        const message = e instanceof HttpErrorResponse ? e.error.message : e;\n        return this.handleError(route, message);\n      }),\n    );\n  }\n\n  private changeNavigation(path: string, route: ActivatedRouteSnapshot): void {\n    const parentUrl = this.routerService.getFlowRootPath(route);\n\n    this.router\n      .navigate([parentUrl + path], {\n        queryParams: route.queryParams,\n        replaceUrl: true,\n      })\n      .catch(e => {\n        const message = e instanceof HttpErrorResponse ? e.error.message : e;\n        return this.handleError(route, message);\n      });\n  }\n\n  private shouldNavigateToAssets(): boolean {\n    if (this.contextService.mode === ConfigurationContextMode.ACCOUNT) {\n      return true;\n    }\n\n    return this.quoteDraftService.quoteDraft?.currentState.some(li => !!li.assetId) ?? false;\n  }\n\n  private accountHasNotAssets(): boolean {\n    return this.contextService.mode === ConfigurationContextMode.ACCOUNT && !this.quoteDraftService.hasProducts;\n  }\n\n  private initializeModifiedAssetsMap(): void {\n    this.integrationState.patchState({\n      modifiedAssets: generateModifiedAssetsMap(this.quoteDraftService.currentState),\n    });\n  }\n}\n"]}

package/esm2020/src/services/doc-gen.service.mjs

@@ -0,0 +1,33 @@
+import { Injectable } from '@angular/core';
+import { FlowAction, IntegrationState } from '@veloceapps/sdk/cms';
+import { BehaviorSubject, Subject, takeUntil, tap } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@veloceapps/sdk/cms";
+export class FlowDocGenService {
+    constructor(integrationState) {
+        this.integrationState = integrationState;
+        this.cleanup$ = new Subject();
+        this.isVisibleSubj$ = new BehaviorSubject(false);
+        this.isVisible$ = this.isVisibleSubj$.asObservable();
+        this.initSubscriptions();
+    }
+    cleanup() {
+        this.cleanup$.next();
+    }
+    initSubscriptions() {
+        this.integrationState
+            .listen$(FlowAction.FLOW_OPEN_DOC_GEN)
+            .pipe(tap(() => this.isVisibleSubj$.next(true)), takeUntil(this.cleanup$))
+            .subscribe();
+        this.integrationState
+            .listen$(FlowAction.FLOW_CLOSE_DOC_GEN)
+            .pipe(tap(() => this.isVisibleSubj$.next(false)), takeUntil(this.cleanup$))
+            .subscribe();
+    }
+}
+FlowDocGenService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: FlowDocGenService, deps: [{ token: i1.IntegrationState }], target: i0.ɵɵFactoryTarget.Injectable });
+FlowDocGenService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: FlowDocGenService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: FlowDocGenService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.IntegrationState }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/services/flow-dialog.service.mjs

@@ -0,0 +1,126 @@
+import { Injectable } from '@angular/core';
+import { ContextService } from '@veloceapps/sdk/core';
+import { DialogService } from 'primeng/dynamicdialog';
+import { FlowDialogComponent } from '../components/dialog/dialog.component';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/dynamicdialog";
+import * as i2 from "@veloceapps/sdk/core";
+export class FlowDialogService {
+    constructor(dialogService, contextService) {
+        this.dialogService = dialogService;
+        this.contextService = contextService;
+    }
+    show(config) {
+        return this.dialogService.open(FlowDialogComponent, {
+            dismissableMask: true,
+            closeOnEscape: true,
+            closable: true,
+            showHeader: true,
+            header: config.title,
+            width: '440px',
+            data: { config },
+        }).onClose;
+    }
+    showEmptyCartDialog() {
+        return this.show({
+            title: 'No Products in Quote',
+            description: 'There are no products in your Quote. To save a Quote, add at least one product.',
+            primaryButton: 'OK',
+        });
+    }
+    showReadonlyModeDialog() {
+        const ctx = this.contextService.resolve();
+        const objectName = ctx.mode ? ctx.mode[0].toUpperCase() + ctx.mode.substring(1).toLowerCase() : 'Object';
+        return this.show({
+            title: 'Error',
+            description: `${objectName} Cannot be Saved`,
+            primaryButton: 'OK',
+        });
+    }
+    showQuoteReadonlyModeDialog() {
+        return this.show({
+            title: 'Quote Cannot be Saved',
+            description: 'It is only possible to save quotes with the “Draft” status. Please create a new quote to make and save changes.',
+            primaryButton: 'OK',
+        });
+    }
+    showQuoteOutsideShoppingCartDialog() {
+        return this.show({
+            title: 'Quote Cannot be Saved',
+            description: 'It is only possible to save quotes from the Shopping Cart. To proceed, go to the Shopping Cart.',
+            primaryButton: 'OK',
+        });
+    }
+    showAccountNoChangesDialog() {
+        return this.show({
+            title: 'No Changes to Save',
+            description: 'There are no changes since the last update. Please make changes to proceed.',
+            primaryButton: 'OK',
+        });
+    }
+    showUnsavedChangesDialog() {
+        return this.show({
+            title: 'Unsaved Changes',
+            description: 'Are you sure you want to leave this page and discard your unsaved changes?',
+            primaryButton: 'Keep Editing',
+            secondaryButton: 'Discard Changes',
+            oppositeButtonActions: true,
+        });
+    }
+    showReadonlyQuoteSubmitFailureDialog() {
+        return this.show({
+            title: 'Cannot Submit for Approval',
+            description: 'It is only possible to submit for approval quotes with the “Draft“ status. Please create a new quote to proceed.',
+            primaryButton: 'OK',
+        });
+    }
+    showOutsideShoppingCartQuoteSubmitFailureDialog() {
+        return this.show({
+            title: 'Cannot Submit for Approval',
+            description: 'It is only possible to submit quotes for approval from the Shopping Cart. To proceed, go to the Shopping Cart.',
+            primaryButton: 'OK',
+        });
+    }
+    showAccountSubmitFailureDialog() {
+        return this.show({
+            title: 'Save Changes',
+            description: 'To submit for approval, save the quote first, and then submit it for approval from the Shopping Cart.',
+            primaryButton: 'OK',
+        });
+    }
+    showDocgenAccountUnsavedChangesDialog() {
+        return this.show({
+            title: 'Save Quote',
+            description: 'To generate a document, save the quote first, and then generate the document from the Shopping Cart.',
+            primaryButton: 'OK',
+        });
+    }
+    showDocgenReadonlyDialog() {
+        return this.show({
+            title: 'Document Generation is not Available',
+            description: 'It is only possible to generate documents for quotes with the “Draft” status. Please create a new quote to generate a document.',
+            primaryButton: 'OK',
+        });
+    }
+    showDocgenOutsideShoppingCartDialog() {
+        return this.show({
+            title: 'Document Generation is not Available',
+            description: 'It is only possible to generate documents for quotes from the Shopping Cart. To proceed, go to the Shopping Cart.',
+            primaryButton: 'OK',
+        });
+    }
+    showDocgenUnsavedChangesDialog() {
+        return this.show({
+            title: 'Unsaved Changes',
+            description: 'To generate a document, save the quote first.',
+            primaryButton: 'Save and proceed',
+            secondaryButton: 'Cancel',
+        });
+    }
+}
+FlowDialogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: FlowDialogService, deps: [{ token: i1.DialogService }, { token: i2.ContextService }], target: i0.ɵɵFactoryTarget.Injectable });
+FlowDialogService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: FlowDialogService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: FlowDialogService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.DialogService }, { type: i2.ContextService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flow-dialog.service.js","sourceRoot":"","sources":["../../../../../../libs/sdk/src/services/flow-dialog.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ContextService } from '@veloceapps/sdk/core';\nimport { DialogService } from 'primeng/dynamicdialog';\nimport { Observable } from 'rxjs';\nimport { FlowDialogComponent } from '../components/dialog/dialog.component';\nimport { FlowDialogConfig } from '../components/dialog/dialog.types';\n\n@Injectable()\nexport class FlowDialogService {\n  constructor(private dialogService: DialogService, private contextService: ContextService) {}\n\n  public show(config: FlowDialogConfig): Observable<boolean> {\n    return this.dialogService.open(FlowDialogComponent, {\n      dismissableMask: true,\n      closeOnEscape: true,\n      closable: true,\n      showHeader: true,\n      header: config.title,\n      width: '440px',\n      data: { config },\n    }).onClose;\n  }\n\n  public showEmptyCartDialog(): Observable<boolean> {\n    return this.show({\n      title: 'No Products in Quote',\n      description: 'There are no products in your Quote. To save a Quote, add at least one product.',\n      primaryButton: 'OK',\n    });\n  }\n\n  public showReadonlyModeDialog(): Observable<boolean> {\n    const ctx = this.contextService.resolve();\n    const objectName = ctx.mode ? ctx.mode[0].toUpperCase() + ctx.mode.substring(1).toLowerCase() : 'Object';\n\n    return this.show({\n      title: 'Error',\n      description: `${objectName} Cannot be Saved`,\n      primaryButton: 'OK',\n    });\n  }\n\n  public showQuoteReadonlyModeDialog(): Observable<boolean> {\n    return this.show({\n      title: 'Quote Cannot be Saved',\n      description:\n        'It is only possible to save quotes with the “Draft” status. Please create a new quote to make and save changes.',\n      primaryButton: 'OK',\n    });\n  }\n\n  public showQuoteOutsideShoppingCartDialog(): Observable<boolean> {\n    return this.show({\n      title: 'Quote Cannot be Saved',\n      description: 'It is only possible to save quotes from the Shopping Cart. To proceed, go to the Shopping Cart.',\n      primaryButton: 'OK',\n    });\n  }\n\n  public showAccountNoChangesDialog(): Observable<boolean> {\n    return this.show({\n      title: 'No Changes to Save',\n      description: 'There are no changes since the last update. Please make changes to proceed.',\n      primaryButton: 'OK',\n    });\n  }\n\n  public showUnsavedChangesDialog(): Observable<boolean> {\n    return this.show({\n      title: 'Unsaved Changes',\n      description: 'Are you sure you want to leave this page and discard your unsaved changes?',\n      primaryButton: 'Keep Editing',\n      secondaryButton: 'Discard Changes',\n      oppositeButtonActions: true,\n    });\n  }\n\n  public showReadonlyQuoteSubmitFailureDialog(): Observable<boolean> {\n    return this.show({\n      title: 'Cannot Submit for Approval',\n      description:\n        'It is only possible to submit for approval quotes with the “Draft“ status. Please create a new quote to proceed.',\n      primaryButton: 'OK',\n    });\n  }\n\n  public showOutsideShoppingCartQuoteSubmitFailureDialog(): Observable<boolean> {\n    return this.show({\n      title: 'Cannot Submit for Approval',\n      description:\n        'It is only possible to submit quotes for approval from the Shopping Cart. To proceed, go to the Shopping Cart.',\n      primaryButton: 'OK',\n    });\n  }\n\n  public showAccountSubmitFailureDialog(): Observable<boolean> {\n    return this.show({\n      title: 'Save Changes',\n      description:\n        'To submit for approval, save the quote first, and then submit it for approval from the Shopping Cart.',\n      primaryButton: 'OK',\n    });\n  }\n\n  public showDocgenAccountUnsavedChangesDialog(): Observable<boolean> {\n    return this.show({\n      title: 'Save Quote',\n      description:\n        'To generate a document, save the quote first, and then generate the document from the Shopping Cart.',\n      primaryButton: 'OK',\n    });\n  }\n\n  public showDocgenReadonlyDialog(): Observable<boolean> {\n    return this.show({\n      title: 'Document Generation is not Available',\n      description:\n        'It is only possible to generate documents for quotes with the “Draft” status. Please create a new quote to generate a document.',\n      primaryButton: 'OK',\n    });\n  }\n\n  public showDocgenOutsideShoppingCartDialog(): Observable<boolean> {\n    return this.show({\n      title: 'Document Generation is not Available',\n      description:\n        'It is only possible to generate documents for quotes from the Shopping Cart. To proceed, go to the Shopping Cart.',\n      primaryButton: 'OK',\n    });\n  }\n\n  public showDocgenUnsavedChangesDialog(): Observable<boolean> {\n    return this.show({\n      title: 'Unsaved Changes',\n      description: 'To generate a document, save the quote first.',\n      primaryButton: 'Save and proceed',\n      secondaryButton: 'Cancel',\n    });\n  }\n}\n"]}