@veloceapps/sdk 5.0.13-0

package/esm2015/src/pages/shopping-cart/shopping-cart.module.js

@@ -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: "12.2.15", ngImport: i0, type: ShoppingCartModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ShoppingCartModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ShoppingCartModule, declarations: [ShoppingCartComponent], imports: [CommonModule, PreviewModule, LoaderModule], exports: [ShoppingCartComponent] });
+ShoppingCartModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ShoppingCartModule, imports: [[CommonModule, PreviewModule, LoaderModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ShoppingCartModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [ShoppingCartComponent],
+                    imports: [CommonModule, PreviewModule, LoaderModule],
+                    exports: [ShoppingCartComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hvcHBpbmctY2FydC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3Nkay9zcmMvcGFnZXMvc2hvcHBpbmctY2FydC9zaG9wcGluZy1jYXJ0Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDdEQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ3BELE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDJCQUEyQixDQUFDOztBQU9sRSxNQUFNLE9BQU8sa0JBQWtCOztnSEFBbEIsa0JBQWtCO2lIQUFsQixrQkFBa0IsaUJBSmQscUJBQXFCLGFBQzFCLFlBQVksRUFBRSxhQUFhLEVBQUUsWUFBWSxhQUN6QyxxQkFBcUI7aUhBRXBCLGtCQUFrQixZQUhwQixDQUFDLFlBQVksRUFBRSxhQUFhLEVBQUUsWUFBWSxDQUFDOzRGQUd6QyxrQkFBa0I7a0JBTDlCLFFBQVE7bUJBQUM7b0JBQ1IsWUFBWSxFQUFFLENBQUMscUJBQXFCLENBQUM7b0JBQ3JDLE9BQU8sRUFBRSxDQUFDLFlBQVksRUFBRSxhQUFhLEVBQUUsWUFBWSxDQUFDO29CQUNwRCxPQUFPLEVBQUUsQ0FBQyxxQkFBcUIsQ0FBQztpQkFDakMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IExvYWRlck1vZHVsZSB9IGZyb20gJ0B2ZWxvY2VhcHBzL2NvbXBvbmVudHMnO1xuaW1wb3J0IHsgUHJldmlld01vZHVsZSB9IGZyb20gJ0B2ZWxvY2VhcHBzL3Nkay9jbXMnO1xuaW1wb3J0IHsgU2hvcHBpbmdDYXJ0Q29tcG9uZW50IH0gZnJvbSAnLi9zaG9wcGluZy1jYXJ0LmNvbXBvbmVudCc7XG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogW1Nob3BwaW5nQ2FydENvbXBvbmVudF0sXG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGUsIFByZXZpZXdNb2R1bGUsIExvYWRlck1vZHVsZV0sXG4gIGV4cG9ydHM6IFtTaG9wcGluZ0NhcnRDb21wb25lbnRdLFxufSlcbmV4cG9ydCBjbGFzcyBTaG9wcGluZ0NhcnRNb2R1bGUge31cbiJdfQ==

package/esm2015/src/resolvers/flow.resolver.js

@@ -0,0 +1,62 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+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 = Object.assign(Object.assign(Object.assign({}, queryParams), flowQueryParams), getDefaultProperties({ flowParams: properties }));
+            const contextProperties = Object.entries(mergedParams).reduce((trunk, [key, value]) => (Object.assign(Object.assign({}, trunk), { [key]: String(value) })), {});
+            this.contextService.update({ properties: contextProperties });
+            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.15", 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: "12.2.15", ngImport: i0, type: FlowResolver });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", 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,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

package/esm2015/src/resolvers/quote.resolver.js

@@ -0,0 +1,74 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { ConfigurationContextMode } from '@veloceapps/core';
+import { catchError, from, of, switchMap, tap } from 'rxjs';
+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";
+export class QuoteResolver {
+    constructor(router, quoteDraftService, routerService, contextService, flowConfiguration) {
+        this.router = router;
+        this.quoteDraftService = quoteDraftService;
+        this.routerService = routerService;
+        this.contextService = contextService;
+        this.flowConfiguration = flowConfiguration;
+    }
+    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;
+        return this.quoteDraftService.init(headerId, queryParams).pipe(switchMap(() => this.calculate$()), tap(() => {
+            if (this.quoteDraftService.isStandalone) {
+                return;
+            }
+            if (this.accountHasNotAssets()) {
+                this.changeNavigation('/empty', route);
+            }
+            else if (!this.quoteDraftService.isInitialized && this.quoteDraftService.hasAssets) {
+                this.changeNavigation('/cart', route);
+            }
+            this.quoteDraftService.isInitialized = true;
+        }), 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);
+        });
+    }
+    accountHasNotAssets() {
+        var _a;
+        return (((_a = this.quoteDraftService.quoteDraft) === null || _a === void 0 ? void 0 : _a.context.properties.mode) === ConfigurationContextMode.ACCOUNT &&
+            !this.quoteDraftService.hasAssets);
+    }
+}
+QuoteResolver.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: QuoteResolver, deps: [{ token: i1.Router }, { token: i2.QuoteDraftService }, { token: i3.FlowRouterService }, { token: i2.ContextService }, { token: i2.FlowConfigurationService }], target: i0.ɵɵFactoryTarget.Injectable });
+QuoteResolver.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: QuoteResolver });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", 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 }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/src/services/doc-gen.service.js

@@ -0,0 +1,33 @@
+import { Injectable } from '@angular/core';
+import { FlowAction } 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: "12.2.15", ngImport: i0, type: FlowDocGenService, deps: [{ token: i1.IntegrationState }], target: i0.ɵɵFactoryTarget.Injectable });
+FlowDocGenService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: FlowDocGenService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: FlowDocGenService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.IntegrationState }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/src/services/flow-dialog.service.js

@@ -0,0 +1,123 @@
+import { Injectable } from '@angular/core';
+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',
+        });
+    }
+    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: "12.2.15", ngImport: i0, type: FlowDialogService, deps: [{ token: i1.DialogService }, { token: i2.ContextService }], target: i0.ɵɵFactoryTarget.Injectable });
+FlowDialogService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: FlowDialogService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", 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    });\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"]}

package/esm2015/src/services/flow-router.service.js

@@ -0,0 +1,136 @@
+import { Injectable } from '@angular/core';
+import { NavigationCancel, NavigationEnd, NavigationError, NavigationStart, } from '@angular/router';
+import { SalesforceIdUtils } from '@veloceapps/core';
+import { distinctUntilChanged, filter, map, shareReplay, startWith } from 'rxjs';
+import { VELOCE_FLOW_ROOT_ROUTE } from '../constants';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@veloceapps/sdk/core";
+export class FlowRouterService {
+    constructor(router, route, contextService) {
+        this.router = router;
+        this.route = route;
+        this.contextService = contextService;
+        this.urlHistory = [];
+        this.getLastChildRoute = (route) => {
+            return route.firstChild ? this.getLastChildRoute(route.firstChild) : route;
+        };
+        this.getNthChildRoute = (route, index) => {
+            if (index <= 0) {
+                return route;
+            }
+            return route.firstChild ? this.getNthChildRoute(route.firstChild, index - 1) : route;
+        };
+        this.getLastChildRouteSnapshot = (route) => {
+            return route.firstChild ? this.getLastChildRouteSnapshot(route.firstChild) : route;
+        };
+        this.watchLastChildRoute$ = (route) => {
+            return this.routeChange$.pipe(map(() => this.getLastChildRouteSnapshot(route.snapshot)));
+        };
+        this.getLastChildParams = (route) => {
+            return route.firstChild ? this.getLastChildParams(route.firstChild) : route.params;
+        };
+        this.watchLastChildParams$ = (route) => {
+            return this.routeChange$.pipe(map(() => this.getLastChildParams(route.snapshot)));
+        };
+        this.getFlowSubpath$ = () => {
+            return this.route$.pipe(map(route => {
+                const url = route.url.join('/');
+                const flowRootUrl = this.getFlowRootPath(route);
+                return url.replace(flowRootUrl, '');
+            }));
+        };
+        this.routeChange$ = this.router.events.pipe(filter(e => e instanceof NavigationEnd), shareReplay());
+        this.lastChildParams$ = this.watchLastChildParams$(this.route).pipe(startWith(this.getLastChildParams(this.route.snapshot)), shareReplay());
+        this.lastChildRoute$ = this.watchLastChildRoute$(this.route).pipe(startWith(this.getLastChildRouteSnapshot(this.route.snapshot)), shareReplay());
+        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());
+        this.router.events.pipe(filter(e => e instanceof NavigationEnd)).subscribe(() => {
+            this.urlHistory.push(this.router.url);
+        });
+    }
+    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;
+    }
+    get route$() {
+        return this.lastChildRoute$;
+    }
+    get params$() {
+        return this.lastChildParams$;
+    }
+    isConfigurationRoute$() {
+        return this.getFlowSubpath$().pipe(map(url => url.startsWith('product')));
+    }
+    isCartRoute$() {
+        return this.getFlowSubpath$().pipe(map(url => url.startsWith('cart')));
+    }
+    isCatalogRoute$() {
+        return this.getFlowSubpath$().pipe(map(url => url.startsWith('catalog')));
+    }
+    navigateBack() {
+        const prevUrl = this.urlHistory[this.urlHistory.length - 2];
+        if (prevUrl) {
+            this.router.navigateByUrl(prevUrl);
+        }
+    }
+    navigateToProductConfiguration(productId, lineItemId) {
+        this.contextService.update({ properties: { productId, lineItemId } });
+        const routeSnapshot = this.getLastChildRouteSnapshot(this.route.snapshot);
+        const flowRouteUrl = this.getFlowRootPath(routeSnapshot);
+        this.router.navigate([flowRouteUrl, 'product'], {
+            queryParams: Object.assign(Object.assign({}, routeSnapshot.queryParams), { productId }),
+        });
+    }
+    navigateToShoppingCart() {
+        const routeSnapshot = this.getLastChildRouteSnapshot(this.route.snapshot);
+        const flowRouteUrl = this.getFlowRootPath(routeSnapshot);
+        this.router.navigate([flowRouteUrl, 'cart'], { queryParams: routeSnapshot.queryParams });
+    }
+    navigateToCatalog() {
+        const routeSnapshot = this.getLastChildRouteSnapshot(this.route.snapshot);
+        const flowRouteUrl = this.getFlowRootPath(routeSnapshot);
+        this.router.navigate([flowRouteUrl, 'catalog'], { queryParams: routeSnapshot.queryParams });
+    }
+    switchObject(id) {
+        const routeSnapshot = this.getLastChildRouteSnapshot(this.route.snapshot);
+        const route = this.getLastChildRoute(this.route);
+        const objName = SalesforceIdUtils.getSfObjectNameById(id);
+        const queryParams = {
+            quoteId: objName === 'Quote' ? id : undefined,
+            accountId: objName === 'Account' ? id : undefined,
+            orderId: objName === 'Order' ? id : undefined,
+        };
+        this.router.navigate([], { relativeTo: route, queryParams: Object.assign(Object.assign({}, routeSnapshot.queryParams), queryParams) });
+    }
+}
+FlowRouterService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: FlowRouterService, deps: [{ token: i1.Router }, { token: i1.ActivatedRoute }, { token: i2.ContextService }], target: i0.ɵɵFactoryTarget.Injectable });
+FlowRouterService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: FlowRouterService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: FlowRouterService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i1.ActivatedRoute }, { type: i2.ContextService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flow-router.service.js","sourceRoot":"","sources":["../../../../../../libs/sdk/src/services/flow-router.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  ActivatedRoute,\n  ActivatedRouteSnapshot,\n  Event,\n  NavigationCancel,\n  NavigationEnd,\n  NavigationError,\n  NavigationStart,\n  Params,\n  Router,\n} from '@angular/router';\nimport { SalesforceIdUtils } from '@veloceapps/core';\nimport { ContextService } from '@veloceapps/sdk/core';\nimport { distinctUntilChanged, filter, map, Observable, shareReplay, startWith } from 'rxjs';\nimport { VELOCE_FLOW_ROOT_ROUTE } from '../constants';\nimport { RouteWithId } from '../types/route.types';\n\n@Injectable({ providedIn: 'root' })\nexport class FlowRouterService {\n  private routeChange$: Observable<Event>;\n  private lastChildParams$: Observable<Params>;\n  private lastChildRoute$: Observable<ActivatedRouteSnapshot>;\n  private urlHistory: string[] = [];\n\n  public loading$: Observable<boolean>;\n\n  constructor(private router: Router, private route: ActivatedRoute, private contextService: ContextService) {\n    this.routeChange$ = this.router.events.pipe(\n      filter(e => e instanceof NavigationEnd),\n      shareReplay(),\n    );\n\n    this.lastChildParams$ = this.watchLastChildParams$(this.route).pipe(\n      startWith(this.getLastChildParams(this.route.snapshot)),\n      shareReplay(),\n    );\n    this.lastChildRoute$ = this.watchLastChildRoute$(this.route).pipe(\n      startWith(this.getLastChildRouteSnapshot(this.route.snapshot)),\n      shareReplay(),\n    );\n\n    this.loading$ = this.router.events.pipe(\n      filter(\n        e =>\n          e instanceof NavigationStart ||\n          e instanceof NavigationCancel ||\n          e instanceof NavigationEnd ||\n          e instanceof NavigationError,\n      ),\n      map(e => e instanceof NavigationStart),\n      startWith(false),\n      distinctUntilChanged(),\n    );\n\n    this.router.events.pipe(filter(e => e instanceof NavigationEnd)).subscribe(() => {\n      this.urlHistory.push(this.router.url);\n    });\n  }\n\n  public getFlowRootRoute(route: ActivatedRouteSnapshot): ActivatedRouteSnapshot | undefined {\n    const path = [...route.pathFromRoot];\n\n    while (path.length) {\n      const parent = path.pop();\n\n      if (!parent) {\n        break;\n      }\n\n      if ((parent.routeConfig as RouteWithId)?.id === VELOCE_FLOW_ROOT_ROUTE) {\n        return parent;\n      }\n    }\n\n    return;\n  }\n\n  public getFlowRootPath(route: ActivatedRouteSnapshot): string {\n    const rootRoute = this.getFlowRootRoute(route);\n    if (!rootRoute) {\n      return '';\n    }\n\n    const path = rootRoute.pathFromRoot\n      .map(r => r.routeConfig?.path)\n      .filter(Boolean)\n      .join('/');\n\n    return '/' + path;\n  }\n\n  public get route$(): Observable<ActivatedRouteSnapshot> {\n    return this.lastChildRoute$;\n  }\n\n  public get params$(): Observable<Params> {\n    return this.lastChildParams$;\n  }\n\n  public getLastChildRoute = (route: ActivatedRoute): ActivatedRoute => {\n    return route.firstChild ? this.getLastChildRoute(route.firstChild) : route;\n  };\n\n  public getNthChildRoute = (route: ActivatedRoute, index: number): ActivatedRoute => {\n    if (index <= 0) {\n      return route;\n    }\n\n    return route.firstChild ? this.getNthChildRoute(route.firstChild, index - 1) : route;\n  };\n\n  public getLastChildRouteSnapshot = (route: ActivatedRouteSnapshot): ActivatedRouteSnapshot => {\n    return route.firstChild ? this.getLastChildRouteSnapshot(route.firstChild) : route;\n  };\n\n  public watchLastChildRoute$ = (route: ActivatedRoute): Observable<ActivatedRouteSnapshot> => {\n    return this.routeChange$.pipe(map(() => this.getLastChildRouteSnapshot(route.snapshot)));\n  };\n\n  public getLastChildParams = (route: ActivatedRouteSnapshot): Params => {\n    return route.firstChild ? this.getLastChildParams(route.firstChild) : route.params;\n  };\n\n  public watchLastChildParams$ = (route: ActivatedRoute): Observable<Params> => {\n    return this.routeChange$.pipe(map(() => this.getLastChildParams(route.snapshot)));\n  };\n\n  public getFlowSubpath$ = (): Observable<string> => {\n    return this.route$.pipe(\n      map(route => {\n        const url = route.url.join('/');\n        const flowRootUrl = this.getFlowRootPath(route);\n        return url.replace(flowRootUrl, '');\n      }),\n    );\n  };\n\n  public isConfigurationRoute$(): Observable<boolean> {\n    return this.getFlowSubpath$().pipe(map(url => url.startsWith('product')));\n  }\n\n  public isCartRoute$(): Observable<boolean> {\n    return this.getFlowSubpath$().pipe(map(url => url.startsWith('cart')));\n  }\n\n  public isCatalogRoute$(): Observable<boolean> {\n    return this.getFlowSubpath$().pipe(map(url => url.startsWith('catalog')));\n  }\n\n  public navigateBack(): void {\n    const prevUrl = this.urlHistory[this.urlHistory.length - 2];\n\n    if (prevUrl) {\n      this.router.navigateByUrl(prevUrl);\n    }\n  }\n\n  public navigateToProductConfiguration(productId: string, lineItemId?: string): void {\n    this.contextService.update({ properties: { productId, lineItemId } });\n\n    const routeSnapshot = this.getLastChildRouteSnapshot(this.route.snapshot);\n    const flowRouteUrl = this.getFlowRootPath(routeSnapshot);\n\n    this.router.navigate([flowRouteUrl, 'product'], {\n      queryParams: { ...routeSnapshot.queryParams, productId },\n    });\n  }\n\n  public navigateToShoppingCart(): void {\n    const routeSnapshot = this.getLastChildRouteSnapshot(this.route.snapshot);\n    const flowRouteUrl = this.getFlowRootPath(routeSnapshot);\n\n    this.router.navigate([flowRouteUrl, 'cart'], { queryParams: routeSnapshot.queryParams });\n  }\n\n  public navigateToCatalog(): void {\n    const routeSnapshot = this.getLastChildRouteSnapshot(this.route.snapshot);\n    const flowRouteUrl = this.getFlowRootPath(routeSnapshot);\n\n    this.router.navigate([flowRouteUrl, 'catalog'], { queryParams: routeSnapshot.queryParams });\n  }\n\n  public switchObject(id: string): void {\n    const routeSnapshot = this.getLastChildRouteSnapshot(this.route.snapshot);\n    const route = this.getLastChildRoute(this.route);\n\n    const objName = SalesforceIdUtils.getSfObjectNameById(id);\n\n    const queryParams = {\n      quoteId: objName === 'Quote' ? id : undefined,\n      accountId: objName === 'Account' ? id : undefined,\n      orderId: objName === 'Order' ? id : undefined,\n    };\n    this.router.navigate([], { relativeTo: route, queryParams: { ...routeSnapshot.queryParams, ...queryParams } });\n  }\n}\n"]}