@veloceapps/sdk 11.0.0-2 → 11.0.0-20

package/esm2020/core/modules/flow-configuration/services/flow-configuration.service.mjs

@@ -1,164 +1,71 @@
 import { Injectable } from '@angular/core';
-import { ProceduresApiService } from '@veloceapps/api';
+import { ProceduresApiService } from '@veloceapps/api/v2';
 import { cloneDeep } from 'lodash';
-import { catchError, map, noop, of, shareReplay, Subject, switchMap, tap, throwError } from 'rxjs';
-import { ContextService } from '../../../services/context.service';
-import { QuoteDraftService } from '../../../services/quote-draft.service';
-import { multiplyLineItems } from '../../../utils/line-item.utils';
-import { ConfigurationService } from '../../configuration/services/configuration.service';
-import { FlowUpdateService } from './flow-update.service';
-import { FlowInfoService } from '../../../services';
+import { catchError, map, noop, of, Subject, switchMap, tap, throwError } from 'rxjs';
+import { SalesTransactionService } from '../../../services/sales-transaction.service';
 import * as i0 from "@angular/core";
-import * as i1 from "@veloceapps/api";
-import * as i2 from "../../../services/context.service";
-import * as i3 from "../../../services/quote-draft.service";
-import * as i4 from "./flow-update.service";
-import * as i5 from "../../configuration/services/configuration.service";
-import * as i6 from "../../../services";
+import * as i1 from "@veloceapps/api/v2";
+import * as i2 from "../../../services/sales-transaction.service";
 export class FlowConfigurationService {
-    constructor(proceduresApiService, contextService, quoteDraftService, updateService, configurationService, flowInfoService) {
+    constructor(proceduresApiService, salesTransactionService) {
         this.proceduresApiService = proceduresApiService;
-        this.contextService = contextService;
-        this.quoteDraftService = quoteDraftService;
-        this.updateService = updateService;
-        this.configurationService = configurationService;
-        this.flowInfoService = flowInfoService;
+        this.salesTransactionService = salesTransactionService;
         this.updatedSubj$ = new Subject();
         this.updated$ = this.updatedSubj$.asObservable();
     }
-    calculate$(quoteDraft) {
-        return this.extendedApply$(quoteDraft).pipe(tap(result => {
-            // sort the result current state based on the quote draft initial state
-            const initialStateIds = quoteDraft.initialState.map(lineItem => lineItem.integrationId);
-            result.currentState = result.currentState
-                .slice()
-                .sort((a, b) => initialStateIds.indexOf(a.integrationId) - initialStateIds.indexOf(b.integrationId));
-            this.quoteDraftService.updateQuoteDraft(result);
-        }), map(noop));
+    calculate$(state) {
+        return this.proceduresApiService.apply$({ salesTransaction: state }).pipe(tap(result => this.salesTransactionService.setState(result.salesTransaction)), map(noop));
     }
-    calculate(quoteDraft) {
-        this.calculate$(quoteDraft).subscribe();
+    calculate(state) {
+        this.calculate$(state).subscribe();
     }
-    update$(updates) {
-        const quoteDraft = this.quoteDraftService.quoteDraft;
-        if (!quoteDraft) {
-            return of(null);
-        }
-        return of([]).pipe(map(() => {
-            const updatedState = cloneDeep(quoteDraft.currentState);
-            this.updateService.update(updatedState, updates, quoteDraft.charges);
-            return updatedState;
-        }), switchMap(updatedState => this.calculate$({ ...quoteDraft, currentState: updatedState })), map(() => this.quoteDraftService.quoteDraft), tap(() => this.updatedSubj$.next()), this.handleErrorAndBounceBack());
-    }
-    update(updates) {
-        this.update$(updates).subscribe();
-    }
-    revert$(lineItemId) {
-        const quoteDraft = this.quoteDraftService.quoteDraft;
-        const initialCurrentState = this.quoteDraftService.getInitialCurrentState();
-        const currentState = this.quoteDraftService.currentState;
-        const currentLineItemIndex = currentState.findIndex(({ id }) => id === lineItemId);
-        const currentLineItem = currentState[currentLineItemIndex];
-        const initialLineItem = initialCurrentState.find(({ integrationId }) => integrationId === currentLineItem?.integrationId);
-        if (!quoteDraft || !currentLineItem || !initialLineItem) {
+    revert$(transactionItemId) {
+        const state = this.salesTransactionService.state;
+        const initialState = this.salesTransactionService.getInitialState();
+        const currentState = state?.salesTransactionItems ?? [];
+        const currentItemIndex = currentState.findIndex(({ id }) => id === transactionItemId);
+        const currentItem = currentState[currentItemIndex];
+        const initialItem = initialState.find(({ integrationId }) => integrationId === currentItem?.integrationId);
+        if (!state || !currentItem || !initialItem) {
             return of(null);
         }
         const updatedState = cloneDeep(currentState);
-        updatedState.splice(currentLineItemIndex, 1, initialLineItem);
+        updatedState.splice(currentItemIndex, 1, initialItem);
         return of([]).pipe(tap(() => {
-            this.quoteDraftService.setCurrentLineItemState(updatedState);
-        }), switchMap(() => this.calculate$({ ...quoteDraft, currentState: updatedState })), map(() => this.quoteDraftService.quoteDraft), tap(() => this.updatedSubj$.next()), this.handleErrorAndBounceBack());
+            this.salesTransactionService.setState({ ...state, salesTransactionItems: updatedState });
+        }), switchMap(() => this.calculate$({ ...state, salesTransactionItems: updatedState })), map(() => this.salesTransactionService.state), tap(() => this.updatedSubj$.next()), this.handleErrorAndBounceBack());
     }
-    revert(lineItemId) {
-        this.revert$(lineItemId).subscribe();
+    revert(transactionItemId) {
+        this.revert$(transactionItemId).subscribe();
     }
     delete$(ids) {
-        const quoteDraft = this.quoteDraftService.quoteDraft;
-        const currentState = this.quoteDraftService.currentState;
-        if (!quoteDraft) {
+        const state = this.salesTransactionService.state;
+        if (!state) {
             return of(null);
         }
-        return of([]).pipe(map(() => ids.reduce((result, id) => this.updateService.delete(result, id), currentState)), switchMap(updatedState => this.calculate$({ ...quoteDraft, currentState: updatedState })), map(() => this.quoteDraftService.quoteDraft), tap(() => this.updatedSubj$.next()), this.handleErrorAndBounceBack());
+        return of([]).pipe(map(() => state.salesTransactionItems.filter(({ id }) => !ids.includes(id))), switchMap(updatedState => this.calculate$({ ...state, salesTransactionItems: updatedState })), map(() => this.salesTransactionService.state), tap(() => this.updatedSubj$.next()), this.handleErrorAndBounceBack());
     }
     delete(ids) {
         this.delete$(ids).subscribe();
     }
-    addTerm$(term) {
-        const quoteDraft = this.quoteDraftService.quoteDraft;
-        if (!quoteDraft) {
-            return of(null);
-        }
-        const updatedState = [...quoteDraft.currentState, term];
-        return of([]).pipe(switchMap(() => this.calculate$({ ...quoteDraft, currentState: updatedState })), map(() => this.quoteDraftService.quoteDraft), tap(() => this.updatedSubj$.next()), this.handleErrorAndBounceBack());
-    }
-    addToCart$(props) {
-        const quoteDraft = this.quoteDraftService.quoteDraft;
-        if (!quoteDraft) {
-            return of(null);
-        }
-        return this.configurationService.configureExternal$(props).pipe(map(lineItem => {
-            const model = this.configurationService.getRuntimeModel();
-            const split = model?.types.find(type => type.name === lineItem.type)?.split ?? false;
-            const lineItems = multiplyLineItems(lineItem, props.qty ?? 1, split);
-            return [...quoteDraft.currentState, ...lineItems];
-        }), switchMap(updatedState => this.calculate$({ ...quoteDraft, currentState: updatedState })), map(() => this.quoteDraftService.quoteDraft), tap(() => this.updatedSubj$.next()), this.handleErrorAndBounceBack());
-    }
-    get() {
-        return this.quoteDraftService.quoteDraft$.pipe(map(() => this.quoteDraftService.currentState), shareReplay());
-    }
-    getSnapshot() {
-        return this.quoteDraftService?.currentState.slice() ?? [];
-    }
-    get charges$() {
-        return this.quoteDraftService.quoteDraft$.pipe(map(({ charges }) => charges));
-    }
-    get pricePlans$() {
-        return this.quoteDraftService.quoteDraft$.pipe(map(({ pricePlans }) => pricePlans));
-    }
-    get activeMetrics$() {
-        return this.quoteDraftService.quoteDraft$.pipe(map(({ activeMetrics }) => activeMetrics));
-    }
-    get chargesSnapshot() {
-        return this.quoteDraftService.quoteDraft?.charges ?? {};
-    }
-    get pricePlansSnapshot() {
-        return this.quoteDraftService.quoteDraft?.pricePlans ?? {};
-    }
-    get activeMetricsSnapshot() {
-        return this.quoteDraftService.quoteDraft?.activeMetrics ?? [];
-    }
-    get contextSnapshot() {
-        return this.contextService.resolve();
-    }
-    get context$() {
-        return this.contextService.resolve$();
-    }
     handleErrorAndBounceBack() {
         return (source$) => {
             return source$.pipe(catchError(error => {
                 console.error(error);
                 // bounce back if configuration call has failed
-                const quoteDraft = this.quoteDraftService.quoteDraft;
-                if (quoteDraft) {
-                    this.quoteDraftService.updateQuoteDraft(quoteDraft);
+                const state = this.salesTransactionService.state;
+                if (state) {
+                    this.salesTransactionService.setState(state);
                     this.updatedSubj$.next();
                 }
                 return throwError(() => error);
             }));
         };
     }
-    extendedApply$(quoteDraft) {
-        const request = { ...quoteDraft };
-        const procedureName = this.flowInfoService.flow?.properties.procedureName;
-        if (procedureName) {
-            request.procedureName = procedureName;
-        }
-        return this.proceduresApiService.apply$(request);
-    }
 }
-FlowConfigurationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowConfigurationService, deps: [{ token: i1.ProceduresApiService }, { token: i2.ContextService }, { token: i3.QuoteDraftService }, { token: i4.FlowUpdateService }, { token: i5.ConfigurationService }, { token: i6.FlowInfoService }], target: i0.ɵɵFactoryTarget.Injectable });
+FlowConfigurationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowConfigurationService, deps: [{ token: i1.ProceduresApiService }, { token: i2.SalesTransactionService }], target: i0.ɵɵFactoryTarget.Injectable });
 FlowConfigurationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowConfigurationService });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowConfigurationService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: i1.ProceduresApiService }, { type: i2.ContextService }, { type: i3.QuoteDraftService }, { type: i4.FlowUpdateService }, { type: i5.ConfigurationService }, { type: i6.FlowInfoService }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flow-configuration.service.js","sourceRoot":"","sources":["../../../../../../../../libs/sdk/core/modules/flow-configuration/services/flow-configuration.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ProceduresApiService } from '@veloceapps/api';\nimport { Charge, CompiledPricePlan, ConfigurationContext, LineItem, MetricRule, QuoteDraft } from '@veloceapps/core';\nimport { cloneDeep, Dictionary } from 'lodash';\nimport { catchError, map, noop, Observable, of, shareReplay, Subject, switchMap, tap, throwError } from 'rxjs';\nimport { ContextService } from '../../../services/context.service';\nimport { QuoteDraftService } from '../../../services/quote-draft.service';\nimport { multiplyLineItems } from '../../../utils/line-item.utils';\nimport { ExternalConfigurationProps } from '../../configuration';\nimport { ConfigurationService } from '../../configuration/services/configuration.service';\nimport { FlowUpdateParams } from '../types/update.types';\nimport { FlowUpdateService } from './flow-update.service';\nimport { FlowInfoService } from '../../../services';\n\n@Injectable()\nexport class FlowConfigurationService {\n  /**\n   * An event being fired when QuoteDraft was updated\n   */\n  public updated$: Observable<void>;\n\n  private updatedSubj$ = new Subject<void>();\n\n  constructor(\n    private proceduresApiService: ProceduresApiService,\n    private contextService: ContextService,\n    private quoteDraftService: QuoteDraftService,\n    private updateService: FlowUpdateService,\n    private configurationService: ConfigurationService,\n    private flowInfoService: FlowInfoService,\n  ) {\n    this.updated$ = this.updatedSubj$.asObservable();\n  }\n\n  public calculate$(quoteDraft: QuoteDraft): Observable<void> {\n    return this.extendedApply$(quoteDraft).pipe(\n      tap(result => {\n        // sort the result current state based on the quote draft initial state\n        const initialStateIds = quoteDraft.initialState.map(lineItem => lineItem.integrationId);\n        result.currentState = result.currentState\n          .slice()\n          .sort((a, b) => initialStateIds.indexOf(a.integrationId) - initialStateIds.indexOf(b.integrationId));\n        this.quoteDraftService.updateQuoteDraft(result);\n      }),\n      map(noop),\n    );\n  }\n\n  public calculate(quoteDraft: QuoteDraft): void {\n    this.calculate$(quoteDraft).subscribe();\n  }\n\n  public update$(updates: FlowUpdateParams[]): Observable<QuoteDraft | null> {\n    const quoteDraft = this.quoteDraftService.quoteDraft;\n\n    if (!quoteDraft) {\n      return of(null);\n    }\n\n    return of([]).pipe(\n      map(() => {\n        const updatedState = cloneDeep(quoteDraft.currentState);\n        this.updateService.update(updatedState, updates, quoteDraft.charges);\n        return updatedState;\n      }),\n      switchMap(updatedState => this.calculate$({ ...quoteDraft, currentState: updatedState })),\n      map(() => this.quoteDraftService.quoteDraft),\n      tap(() => this.updatedSubj$.next()),\n      this.handleErrorAndBounceBack(),\n    );\n  }\n\n  public update(updates: FlowUpdateParams[]): void {\n    this.update$(updates).subscribe();\n  }\n\n  public revert$(lineItemId: string): Observable<QuoteDraft | null> {\n    const quoteDraft = this.quoteDraftService.quoteDraft;\n    const initialCurrentState = this.quoteDraftService.getInitialCurrentState();\n    const currentState = this.quoteDraftService.currentState;\n\n    const currentLineItemIndex = currentState.findIndex(({ id }) => id === lineItemId);\n    const currentLineItem = currentState[currentLineItemIndex];\n\n    const initialLineItem = initialCurrentState.find(\n      ({ integrationId }) => integrationId === currentLineItem?.integrationId,\n    );\n\n    if (!quoteDraft || !currentLineItem || !initialLineItem) {\n      return of(null);\n    }\n\n    const updatedState = cloneDeep(currentState);\n    updatedState.splice(currentLineItemIndex, 1, initialLineItem);\n\n    return of([]).pipe(\n      tap(() => {\n        this.quoteDraftService.setCurrentLineItemState(updatedState);\n      }),\n      switchMap(() => this.calculate$({ ...quoteDraft, currentState: updatedState })),\n      map(() => this.quoteDraftService.quoteDraft),\n      tap(() => this.updatedSubj$.next()),\n      this.handleErrorAndBounceBack(),\n    );\n  }\n\n  public revert(lineItemId: string): void {\n    this.revert$(lineItemId).subscribe();\n  }\n\n  public delete$(ids: string[]): Observable<QuoteDraft | null> {\n    const quoteDraft = this.quoteDraftService.quoteDraft;\n    const currentState = this.quoteDraftService.currentState;\n\n    if (!quoteDraft) {\n      return of(null);\n    }\n\n    return of([]).pipe(\n      map(() => ids.reduce((result, id) => this.updateService.delete(result, id), currentState)),\n      switchMap(updatedState => this.calculate$({ ...quoteDraft, currentState: updatedState })),\n      map(() => this.quoteDraftService.quoteDraft),\n      tap(() => this.updatedSubj$.next()),\n      this.handleErrorAndBounceBack(),\n    );\n  }\n\n  public delete(ids: string[]): void {\n    this.delete$(ids).subscribe();\n  }\n\n  public addTerm$(term: LineItem): Observable<QuoteDraft | null> {\n    const quoteDraft = this.quoteDraftService.quoteDraft;\n\n    if (!quoteDraft) {\n      return of(null);\n    }\n\n    const updatedState = [...quoteDraft.currentState, term];\n\n    return of([]).pipe(\n      switchMap(() => this.calculate$({ ...quoteDraft, currentState: updatedState })),\n      map(() => this.quoteDraftService.quoteDraft),\n      tap(() => this.updatedSubj$.next()),\n      this.handleErrorAndBounceBack(),\n    );\n  }\n\n  public addToCart$(props: ExternalConfigurationProps): Observable<QuoteDraft | null> {\n    const quoteDraft = this.quoteDraftService.quoteDraft;\n\n    if (!quoteDraft) {\n      return of(null);\n    }\n\n    return this.configurationService.configureExternal$(props).pipe(\n      map(lineItem => {\n        const model = this.configurationService.getRuntimeModel();\n        const split = model?.types.find(type => type.name === lineItem.type)?.split ?? false;\n        const lineItems = multiplyLineItems(lineItem, props.qty ?? 1, split);\n\n        return [...quoteDraft.currentState, ...lineItems];\n      }),\n      switchMap(updatedState => this.calculate$({ ...quoteDraft, currentState: updatedState })),\n      map(() => this.quoteDraftService.quoteDraft),\n      tap(() => this.updatedSubj$.next()),\n      this.handleErrorAndBounceBack(),\n    );\n  }\n\n  public get(): Observable<LineItem[]> {\n    return this.quoteDraftService.quoteDraft$.pipe(\n      map(() => this.quoteDraftService.currentState),\n      shareReplay(),\n    );\n  }\n\n  public getSnapshot(): LineItem[] {\n    return this.quoteDraftService?.currentState.slice() ?? [];\n  }\n\n  public get charges$(): Observable<Dictionary<Charge>> {\n    return this.quoteDraftService.quoteDraft$.pipe(map(({ charges }) => charges));\n  }\n\n  public get pricePlans$(): Observable<Dictionary<CompiledPricePlan>> {\n    return this.quoteDraftService.quoteDraft$.pipe(map(({ pricePlans }) => pricePlans));\n  }\n\n  public get activeMetrics$(): Observable<MetricRule[]> {\n    return this.quoteDraftService.quoteDraft$.pipe(map(({ activeMetrics }) => activeMetrics));\n  }\n\n  public get chargesSnapshot(): Dictionary<Charge> {\n    return this.quoteDraftService.quoteDraft?.charges ?? {};\n  }\n\n  public get pricePlansSnapshot(): Dictionary<CompiledPricePlan> {\n    return this.quoteDraftService.quoteDraft?.pricePlans ?? {};\n  }\n\n  public get activeMetricsSnapshot(): MetricRule[] {\n    return this.quoteDraftService.quoteDraft?.activeMetrics ?? [];\n  }\n\n  public get contextSnapshot(): ConfigurationContext {\n    return this.contextService.resolve();\n  }\n\n  public get context$(): Observable<ConfigurationContext> {\n    return this.contextService.resolve$();\n  }\n\n  private handleErrorAndBounceBack() {\n    return <T>(source$: Observable<T>): Observable<T> => {\n      return source$.pipe(\n        catchError(error => {\n          console.error(error);\n\n          // bounce back if configuration call has failed\n          const quoteDraft = this.quoteDraftService.quoteDraft;\n          if (quoteDraft) {\n            this.quoteDraftService.updateQuoteDraft(quoteDraft);\n            this.updatedSubj$.next();\n          }\n\n          return throwError(() => error);\n        }),\n      );\n    };\n  }\n\n  private extendedApply$(quoteDraft: QuoteDraft): Observable<QuoteDraft> {\n    const request = { ...quoteDraft };\n    const procedureName = this.flowInfoService.flow?.properties.procedureName;\n    if (procedureName) {\n      request.procedureName = procedureName;\n    }\n    return this.proceduresApiService.apply$(request);\n  }\n}\n"]}
+        }], ctorParameters: function () { return [{ type: i1.ProceduresApiService }, { type: i2.SalesTransactionService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flow-configuration.service.js","sourceRoot":"","sources":["../../../../../../../../libs/sdk/core/modules/flow-configuration/services/flow-configuration.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ProceduresApiService } from '@veloceapps/api/v2';\nimport { SalesTransaction } from '@veloceapps/core';\nimport { cloneDeep } from 'lodash';\nimport { catchError, map, noop, Observable, of, Subject, switchMap, tap, throwError } from 'rxjs';\nimport { SalesTransactionService } from '../../../services/sales-transaction.service';\n\n@Injectable()\nexport class FlowConfigurationService {\n  public updated$: Observable<void>;\n\n  private updatedSubj$ = new Subject<void>();\n\n  constructor(\n    private proceduresApiService: ProceduresApiService,\n    private salesTransactionService: SalesTransactionService,\n  ) {\n    this.updated$ = this.updatedSubj$.asObservable();\n  }\n\n  public calculate$(state: SalesTransaction): Observable<void> {\n    return this.proceduresApiService.apply$({ salesTransaction: state }).pipe(\n      tap(result => this.salesTransactionService.setState(result.salesTransaction)),\n      map(noop),\n    );\n  }\n\n  public calculate(state: SalesTransaction): void {\n    this.calculate$(state).subscribe();\n  }\n\n  public revert$(transactionItemId: string): Observable<SalesTransaction | null> {\n    const state = this.salesTransactionService.state;\n    const initialState = this.salesTransactionService.getInitialState();\n    const currentState = state?.salesTransactionItems ?? [];\n\n    const currentItemIndex = currentState.findIndex(({ id }) => id === transactionItemId);\n    const currentItem = currentState[currentItemIndex];\n\n    const initialItem = initialState.find(({ integrationId }) => integrationId === currentItem?.integrationId);\n\n    if (!state || !currentItem || !initialItem) {\n      return of(null);\n    }\n\n    const updatedState = cloneDeep(currentState);\n    updatedState.splice(currentItemIndex, 1, initialItem);\n\n    return of([]).pipe(\n      tap(() => {\n        this.salesTransactionService.setState({ ...state, salesTransactionItems: updatedState });\n      }),\n      switchMap(() => this.calculate$({ ...state, salesTransactionItems: updatedState })),\n      map(() => this.salesTransactionService.state),\n      tap(() => this.updatedSubj$.next()),\n      this.handleErrorAndBounceBack(),\n    );\n  }\n\n  public revert(transactionItemId: string): void {\n    this.revert$(transactionItemId).subscribe();\n  }\n\n  public delete$(ids: string[]): Observable<SalesTransaction | null> {\n    const state = this.salesTransactionService.state;\n    if (!state) {\n      return of(null);\n    }\n\n    return of([]).pipe(\n      map(() => state.salesTransactionItems.filter(({ id }) => !ids.includes(id))),\n      switchMap(updatedState => this.calculate$({ ...state, salesTransactionItems: updatedState })),\n      map(() => this.salesTransactionService.state),\n      tap(() => this.updatedSubj$.next()),\n      this.handleErrorAndBounceBack(),\n    );\n  }\n\n  public delete(ids: string[]): void {\n    this.delete$(ids).subscribe();\n  }\n\n  private handleErrorAndBounceBack() {\n    return <T>(source$: Observable<T>): Observable<T> => {\n      return source$.pipe(\n        catchError(error => {\n          console.error(error);\n\n          // bounce back if configuration call has failed\n          const state = this.salesTransactionService.state;\n          if (state) {\n            this.salesTransactionService.setState(state);\n            this.updatedSubj$.next();\n          }\n\n          return throwError(() => error);\n        }),\n      );\n    };\n  }\n}\n"]}

package/esm2020/core/services/catalog-products.service.mjs

@@ -0,0 +1,25 @@
+import { Injectable } from '@angular/core';
+import { isDefined } from '@veloceapps/core';
+import { BehaviorSubject, filter } from 'rxjs';
+import * as i0 from "@angular/core";
+export class CatalogProductsService {
+    constructor() {
+        this.stateSubj$ = new BehaviorSubject(null);
+        this.state$ = this.stateSubj$.asObservable().pipe(filter(isDefined));
+    }
+    get state() {
+        return this.stateSubj$.getValue();
+    }
+    reset() {
+        this.stateSubj$.next(null);
+    }
+    setState(state) {
+        this.stateSubj$.next(state);
+    }
+}
+CatalogProductsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CatalogProductsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+CatalogProductsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CatalogProductsService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CatalogProductsService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2F0YWxvZy1wcm9kdWN0cy5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9zZGsvY29yZS9zZXJ2aWNlcy9jYXRhbG9nLXByb2R1Y3RzLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQW1CLFNBQVMsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQzlELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxFQUFFLE1BQU0sTUFBTSxDQUFDOztBQUcvQyxNQUFNLE9BQU8sc0JBQXNCO0lBRG5DO1FBRVUsZUFBVSxHQUFHLElBQUksZUFBZSxDQUF5QixJQUFJLENBQUMsQ0FBQztRQUVoRSxXQUFNLEdBQUcsSUFBSSxDQUFDLFVBQVUsQ0FBQyxZQUFZLEVBQUUsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUM7S0FheEU7SUFYQyxJQUFXLEtBQUs7UUFDZCxPQUFPLElBQUksQ0FBQyxVQUFVLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDcEMsQ0FBQztJQUVNLEtBQUs7UUFDVixJQUFJLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUM3QixDQUFDO0lBRU0sUUFBUSxDQUFDLEtBQXNCO1FBQ3BDLElBQUksQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQzlCLENBQUM7O21IQWZVLHNCQUFzQjt1SEFBdEIsc0JBQXNCOzJGQUF0QixzQkFBc0I7a0JBRGxDLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDYXRhbG9nUHJvZHVjdHMsIGlzRGVmaW5lZCB9IGZyb20gJ0B2ZWxvY2VhcHBzL2NvcmUnO1xuaW1wb3J0IHsgQmVoYXZpb3JTdWJqZWN0LCBmaWx0ZXIgfSBmcm9tICdyeGpzJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIENhdGFsb2dQcm9kdWN0c1NlcnZpY2Uge1xuICBwcml2YXRlIHN0YXRlU3ViaiQgPSBuZXcgQmVoYXZpb3JTdWJqZWN0PENhdGFsb2dQcm9kdWN0cyB8IG51bGw+KG51bGwpO1xuXG4gIHB1YmxpYyBzdGF0ZSQgPSB0aGlzLnN0YXRlU3ViaiQuYXNPYnNlcnZhYmxlKCkucGlwZShmaWx0ZXIoaXNEZWZpbmVkKSk7XG5cbiAgcHVibGljIGdldCBzdGF0ZSgpOiBDYXRhbG9nUHJvZHVjdHMgfCBudWxsIHtcbiAgICByZXR1cm4gdGhpcy5zdGF0ZVN1YmokLmdldFZhbHVlKCk7XG4gIH1cblxuICBwdWJsaWMgcmVzZXQoKTogdm9pZCB7XG4gICAgdGhpcy5zdGF0ZVN1YmokLm5leHQobnVsbCk7XG4gIH1cblxuICBwdWJsaWMgc2V0U3RhdGUoc3RhdGU6IENhdGFsb2dQcm9kdWN0cyk6IHZvaWQge1xuICAgIHRoaXMuc3RhdGVTdWJqJC5uZXh0KHN0YXRlKTtcbiAgfVxufVxuIl19

package/esm2020/core/services/flow-info.service.mjs

@@ -1,61 +1,102 @@
 import { Inject, Injectable, Optional } from '@angular/core';
-import { FlowsApiService, UITemplatesApiService } from '@veloceapps/api';
-import { UITemplateType } from '@veloceapps/core';
-import { BehaviorSubject, catchError, forkJoin, map, noop, of, switchMap, tap, throwError } from 'rxjs';
-import { FLOW_CUSTOMIZATION } from '../types';
+import { UITemplatesApiService } from '@veloceapps/api/v2';
+import { SalesforceIdUtils, UITemplateType, } from '@veloceapps/core';
+import { BehaviorSubject, forkJoin, map, of, switchMap } from 'rxjs';
+import { FLOW_CUSTOMIZATION } from '../types/flow-customization.types';
+import { RuntimeSettingsService } from './runtime-settings.service';
 import * as i0 from "@angular/core";
-import * as i1 from "@veloceapps/api";
+import * as i1 from "./runtime-settings.service";
+import * as i2 from "@veloceapps/api/v2";
 export class FlowInfoService {
     get flow() {
+        if (!this.flowSubj$.value) {
+            throw new Error(`Flow not initialized yet`);
+        }
         return this.flowSubj$.value;
     }
-    set flow(value) {
-        this.flowSubj$.next(value);
+    get isFlowInitialized() {
+        return Boolean(this.flowSubj$.value);
+    }
+    get context() {
+        if (!this.contextSubj$.value) {
+            throw new Error('Context is not initialized yet!');
+        }
+        return { ...this.contextSubj$.value };
+    }
+    get templates() {
+        return this.templatesSubj$.value;
     }
-    get isLegacy() {
-        return !!this.flow && this.flow?.properties.stateful == null;
+    get isFlowEngineInitialized$() {
+        return this.templates$.pipe(map(v => Boolean(v.FLOW_ENGINE)));
     }
     get isStateful() {
         return !!this.flow?.properties.stateful;
     }
-    constructor(flowsApiService, templatesApiService, customizationService) {
-        this.flowsApiService = flowsApiService;
+    constructor(runtimeSettingsService, templatesApiService, customizationService) {
+        this.runtimeSettingsService = runtimeSettingsService;
         this.templatesApiService = templatesApiService;
         this.customizationService = customizationService;
-        this.templates = {};
         this.defaultTemplates = {
             flowEngine: 'Flow Engine',
         };
         this.flowSubj$ = new BehaviorSubject(null);
+        this.templatesSubj$ = new BehaviorSubject({});
+        this.contextSubj$ = new BehaviorSubject(null);
         this.flow$ = this.flowSubj$.asObservable();
+        this.templates$ = this.templatesSubj$.asObservable();
+    }
+    reset() {
+        this.flowSubj$.next(null);
+        this.templatesSubj$.next({});
+        this.contextSubj$.next(null);
     }
     init$(flowId, routeQueryParams) {
-        return this.flowsApiService.getFlow(flowId).pipe(switchMap(flow => this.initFlowTemplates$(flow).pipe(map(() => flow))), tap(flow => {
-            this.params = { ...routeQueryParams, ...flow.properties.queryParams };
-            this.flowSubj$.next(flow);
-        }), map(noop), catchError(e => {
-            this.flowSubj$.next(null);
-            return throwError(() => e);
-        }));
+        return this.initFlow$(flowId, routeQueryParams).pipe(switchMap(() => this.initFlowTemplates$()));
     }
-    cleanup() {
-        this.flowSubj$.next(null);
-        this.params = undefined;
-        this.templates = {};
+    updateContext(update) {
+        this.contextSubj$.next({
+            ...this.context,
+            ...update,
+        });
+    }
+    initFlow$(flowId, routeQueryParams) {
+        const flow = this.runtimeSettingsService.getConfigurationSettings()['flows']?.find(({ id }) => flowId === id);
+        if (!flow) {
+            this.flowSubj$.next(null);
+            throw new Error(`Flow with flowId=${flowId} is not defined`);
+        }
+        const headerId = routeQueryParams['headerId'];
+        if (typeof headerId !== 'string') {
+            throw new Error(`Please provide 'headerId'`);
+        }
+        const mode = this.getFlowContextMode(headerId);
+        // Restrict if mode is not defined
+        if (mode == null) {
+            throw new Error('Mode is undefined');
+        }
+        this.contextSubj$.next({
+            ...flow.properties.queryParams,
+            ...routeQueryParams,
+            mode,
+        });
+        this.flowSubj$.next(flow);
+        return of(undefined);
     }
-    initFlowTemplates$(flow) {
+    initFlowTemplates$() {
         return forkJoin([
             this.templatesApiService.fetchTemplates$(),
             this.customizationService?.getTemplates?.() ?? of([]),
         ]).pipe(map(([templates, localTemplates]) => {
-            Object.entries({ ...this.defaultTemplates, ...flow.properties.templates }).forEach(([key, name]) => {
+            const newValue = {};
+            Object.entries({ ...this.defaultTemplates, ...(this.flow?.properties.templates ?? {}) }).forEach(([key, name]) => {
                 const type = this.remapTemplateName(key);
                 if (type) {
-                    this.templates[type] =
+                    newValue[type] =
                         localTemplates.find(template => template.name === name && template.type === type) ??
                             templates.find(template => template.name === name && template.type === type);
                 }
             });
+            this.templatesSubj$.next(newValue);
         }));
     }
     remapTemplateName(templateType) {
@@ -81,15 +122,22 @@ export class FlowInfoService {
         }
         return undefined;
     }
+    getFlowContextMode(headerId) {
+        const objectName = SalesforceIdUtils.getSfObjectNameById(headerId);
+        if (!objectName) {
+            return;
+        }
+        return objectName.toUpperCase();
+    }
 }
-FlowInfoService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowInfoService, deps: [{ token: i1.FlowsApiService }, { token: i1.UITemplatesApiService }, { token: FLOW_CUSTOMIZATION, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+FlowInfoService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowInfoService, deps: [{ token: i1.RuntimeSettingsService }, { token: i2.UITemplatesApiService }, { token: FLOW_CUSTOMIZATION, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
 FlowInfoService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowInfoService });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowInfoService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: i1.FlowsApiService }, { type: i1.UITemplatesApiService }, { type: undefined, decorators: [{
+        }], ctorParameters: function () { return [{ type: i1.RuntimeSettingsService }, { type: i2.UITemplatesApiService }, { type: undefined, decorators: [{
                     type: Optional
                 }, {
                     type: Inject,
                     args: [FLOW_CUSTOMIZATION]
                 }] }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flow-info.service.js","sourceRoot":"","sources":["../../../../../../libs/sdk/core/services/flow-info.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core';\nimport { Params } from '@angular/router';\nimport { FlowsApiService, UITemplatesApiService } from '@veloceapps/api';\nimport { Flow, FlowTemplatesMap, UITemplate, UITemplateType } from '@veloceapps/core';\nimport { BehaviorSubject, catchError, forkJoin, map, noop, Observable, of, switchMap, tap, throwError } from 'rxjs';\nimport { FLOW_CUSTOMIZATION, FlowCustomization } from '../types';\n\n@Injectable()\nexport class FlowInfoService {\n  public flow$: Observable<Flow | null>;\n  public params?: Params;\n  public templates: { [key in UITemplateType]?: UITemplate } = {};\n\n  public get flow(): Flow | null {\n    return this.flowSubj$.value;\n  }\n  public set flow(value: Flow | null) {\n    this.flowSubj$.next(value);\n  }\n\n  public get isLegacy(): boolean {\n    return !!this.flow && this.flow?.properties.stateful == null;\n  }\n\n  public get isStateful(): boolean {\n    return !!this.flow?.properties.stateful;\n  }\n\n  private readonly defaultTemplates = {\n    flowEngine: 'Flow Engine',\n  };\n  private flowSubj$ = new BehaviorSubject<Flow | null>(null);\n\n  constructor(\n    private flowsApiService: FlowsApiService,\n    private templatesApiService: UITemplatesApiService,\n    @Optional() @Inject(FLOW_CUSTOMIZATION) private customizationService?: FlowCustomization,\n  ) {\n    this.flow$ = this.flowSubj$.asObservable();\n  }\n\n  public init$(flowId: string, routeQueryParams: Params): Observable<void> {\n    return this.flowsApiService.getFlow(flowId).pipe(\n      switchMap(flow => this.initFlowTemplates$(flow).pipe(map(() => flow))),\n      tap(flow => {\n        this.params = { ...routeQueryParams, ...flow.properties.queryParams };\n        this.flowSubj$.next(flow);\n      }),\n      map(noop),\n      catchError(e => {\n        this.flowSubj$.next(null);\n        return throwError(() => e);\n      }),\n    );\n  }\n\n  public cleanup(): void {\n    this.flowSubj$.next(null);\n    this.params = undefined;\n    this.templates = {};\n  }\n\n  private initFlowTemplates$(flow: Flow): Observable<void> {\n    return forkJoin([\n      this.templatesApiService.fetchTemplates$(),\n      this.customizationService?.getTemplates?.() ?? of([]),\n    ]).pipe(\n      map(([templates, localTemplates]) => {\n        Object.entries({ ...this.defaultTemplates, ...flow.properties.templates }).forEach(([key, name]) => {\n          const type = this.remapTemplateName(key);\n\n          if (type) {\n            this.templates[type] =\n              localTemplates.find(template => template.name === name && template.type === type) ??\n              templates.find(template => template.name === name && template.type === type);\n          }\n        });\n      }),\n    );\n  }\n\n  private remapTemplateName(templateType: string): UITemplateType | undefined {\n    switch (templateType as keyof typeof this.defaultTemplates) {\n      case 'flowEngine':\n        return UITemplateType.FLOW_ENGINE;\n      default:\n        break;\n    }\n\n    switch (templateType as keyof FlowTemplatesMap) {\n      case 'assets':\n      case 'shoppingCart':\n        // No separate Assets template at the moment\n        return UITemplateType.SHOPPING_CART;\n      case 'catalog':\n        return UITemplateType.CATALOG;\n      case 'guidedSelling':\n        return UITemplateType.GUIDED_SELLING;\n      case 'flowHeader':\n        return UITemplateType.FLOW_HEADER;\n      default:\n        break;\n    }\n\n    return undefined;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flow-info.service.js","sourceRoot":"","sources":["../../../../../../libs/sdk/core/services/flow-info.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core';\nimport { Params } from '@angular/router';\nimport { UITemplatesApiService } from '@veloceapps/api/v2';\nimport {\n  Flow,\n  FlowContext,\n  FlowContextMode,\n  FlowTemplatesMap,\n  SalesforceIdUtils,\n  UITemplate,\n  UITemplateType,\n} from '@veloceapps/core';\nimport { BehaviorSubject, forkJoin, map, Observable, of, switchMap } from 'rxjs';\nimport { FlowCustomization, FLOW_CUSTOMIZATION } from '../types/flow-customization.types';\nimport { RuntimeSettingsService } from './runtime-settings.service';\n\n@Injectable()\nexport class FlowInfoService {\n  public flow$: Observable<Flow | null>;\n  public templates$: Observable<{ [key in UITemplateType]?: UITemplate }>;\n\n  public get flow(): Flow {\n    if (!this.flowSubj$.value) {\n      throw new Error(`Flow not initialized yet`);\n    }\n\n    return this.flowSubj$.value;\n  }\n\n  public get isFlowInitialized(): boolean {\n    return Boolean(this.flowSubj$.value);\n  }\n\n  public get context(): FlowContext {\n    if (!this.contextSubj$.value) {\n      throw new Error('Context is not initialized yet!');\n    }\n\n    return { ...this.contextSubj$.value };\n  }\n\n  public get templates() {\n    return this.templatesSubj$.value;\n  }\n\n  public get isFlowEngineInitialized$(): Observable<boolean> {\n    return this.templates$.pipe(map(v => Boolean(v.FLOW_ENGINE)));\n  }\n\n  public get isStateful(): boolean {\n    return !!this.flow?.properties.stateful;\n  }\n\n  private readonly defaultTemplates = {\n    flowEngine: 'Flow Engine',\n  };\n  private flowSubj$ = new BehaviorSubject<Flow | null>(null);\n  private templatesSubj$ = new BehaviorSubject<{ [key in UITemplateType]?: UITemplate }>({});\n  private contextSubj$ = new BehaviorSubject<FlowContext | null>(null);\n\n  constructor(\n    private runtimeSettingsService: RuntimeSettingsService,\n    private templatesApiService: UITemplatesApiService,\n    @Optional() @Inject(FLOW_CUSTOMIZATION) private customizationService?: FlowCustomization,\n  ) {\n    this.flow$ = this.flowSubj$.asObservable();\n    this.templates$ = this.templatesSubj$.asObservable();\n  }\n\n  public reset(): void {\n    this.flowSubj$.next(null);\n    this.templatesSubj$.next({});\n    this.contextSubj$.next(null);\n  }\n\n  public init$(flowId: string, routeQueryParams: Params): Observable<void> {\n    return this.initFlow$(flowId, routeQueryParams).pipe(switchMap(() => this.initFlowTemplates$()));\n  }\n\n  public updateContext(update: Partial<FlowContext>): void {\n    this.contextSubj$.next({\n      ...this.context,\n      ...update,\n    });\n  }\n\n  private initFlow$(flowId: string, routeQueryParams: Params): Observable<void> {\n    const flow = this.runtimeSettingsService.getConfigurationSettings()['flows']?.find(({ id }) => flowId === id);\n    if (!flow) {\n      this.flowSubj$.next(null);\n      throw new Error(`Flow with flowId=${flowId} is not defined`);\n    }\n\n    const headerId = routeQueryParams['headerId'];\n    if (typeof headerId !== 'string') {\n      throw new Error(`Please provide 'headerId'`);\n    }\n\n    const mode = this.getFlowContextMode(headerId);\n\n    // Restrict if mode is not defined\n    if (mode == null) {\n      throw new Error('Mode is undefined');\n    }\n\n    this.contextSubj$.next({\n      ...flow.properties.queryParams,\n      ...routeQueryParams,\n      mode,\n    } as FlowContext);\n\n    this.flowSubj$.next(flow);\n    return of(undefined);\n  }\n\n  private initFlowTemplates$(): Observable<void> {\n    return forkJoin([\n      this.templatesApiService.fetchTemplates$(),\n      this.customizationService?.getTemplates?.() ?? of([]),\n    ]).pipe(\n      map(([templates, localTemplates]) => {\n        const newValue: { [key in UITemplateType]?: UITemplate } = {};\n        Object.entries({ ...this.defaultTemplates, ...(this.flow?.properties.templates ?? {}) }).forEach(\n          ([key, name]) => {\n            const type = this.remapTemplateName(key);\n\n            if (type) {\n              newValue[type] =\n                localTemplates.find(template => template.name === name && template.type === type) ??\n                templates.find(template => template.name === name && template.type === type);\n            }\n          },\n        );\n\n        this.templatesSubj$.next(newValue);\n      }),\n    );\n  }\n\n  private remapTemplateName(templateType: string): UITemplateType | undefined {\n    switch (templateType as keyof typeof this.defaultTemplates) {\n      case 'flowEngine':\n        return UITemplateType.FLOW_ENGINE;\n      default:\n        break;\n    }\n\n    switch (templateType as keyof FlowTemplatesMap) {\n      case 'assets':\n      case 'shoppingCart':\n        // No separate Assets template at the moment\n        return UITemplateType.SHOPPING_CART;\n      case 'catalog':\n        return UITemplateType.CATALOG;\n      case 'guidedSelling':\n        return UITemplateType.GUIDED_SELLING;\n      case 'flowHeader':\n        return UITemplateType.FLOW_HEADER;\n      default:\n        break;\n    }\n\n    return undefined;\n  }\n\n  private getFlowContextMode(headerId: string): FlowContextMode | undefined {\n    const objectName = SalesforceIdUtils.getSfObjectNameById(headerId);\n    if (!objectName) {\n      return;\n    }\n\n    return objectName.toUpperCase() as FlowContextMode;\n  }\n}\n"]}

package/esm2020/core/services/flow-state-configuration.service.mjs

@@ -1,25 +1,14 @@
 import { Injectable } from '@angular/core';
-import { FlowStateApiService } from '@veloceapps/api';
-import { BehaviorSubject, map, noop, of, switchMap, tap } from 'rxjs';
-import { generateConfigurationLineItem } from '../modules/configuration';
-import { FlowConfigurationService } from '../modules/flow-configuration';
+import { map, noop, of, switchMap } from 'rxjs';
 import { FlowInfoService } from './flow-info.service';
 import { FlowStateService } from './flow-state.service';
 import * as i0 from "@angular/core";
 import * as i1 from "./flow-info.service";
-import * as i2 from "../modules/flow-configuration";
-import * as i3 from "@veloceapps/api";
-import * as i4 from "./flow-state.service";
+import * as i2 from "./flow-state.service";
 export class FlowStateConfigurationService {
-    constructor(flowInfoService, flowConfigurationService, flowStateApiService, flowStateService) {
+    constructor(flowInfoService, flowStateService) {
         this.flowInfoService = flowInfoService;
-        this.flowConfigurationService = flowConfigurationService;
-        this.flowStateApiService = flowStateApiService;
         this.flowStateService = flowStateService;
-        this.configurationStateId$ = new BehaviorSubject(null);
-    }
-    get configurationStateId() {
-        return this.configurationStateId$.value;
     }
     addToCart$(props) {
         let request$;
@@ -30,24 +19,20 @@ export class FlowStateConfigurationService {
                 request$ = of();
             }
             else {
-                const lineItem = generateConfigurationLineItem(props, props.qty);
-                request$ = this.flowStateApiService.newConfiguration(stateId, { lineItem }).pipe(tap(r => this.configurationStateId$.next(r.stateId)), switchMap(() => {
-                    if (!this.configurationStateId) {
-                        return of();
-                    }
-                    return this.flowStateApiService.saveConfiguration(stateId, this.configurationStateId).pipe(tap(() => this.configurationStateId$.next(null)), map(noop));
-                }));
+                // TODO: Implement
+                request$ = of();
             }
         }
         else {
-            request$ = this.flowConfigurationService.addToCart$(props).pipe(map(noop));
+            // TODO: Implement
+            request$ = of();
         }
         return request$.pipe(switchMap(() => this.flowStateService.executeRequest$({}, true)), map(noop));
     }
 }
-FlowStateConfigurationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowStateConfigurationService, deps: [{ token: i1.FlowInfoService }, { token: i2.FlowConfigurationService }, { token: i3.FlowStateApiService }, { token: i4.FlowStateService }], target: i0.ɵɵFactoryTarget.Injectable });
+FlowStateConfigurationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowStateConfigurationService, deps: [{ token: i1.FlowInfoService }, { token: i2.FlowStateService }], target: i0.ɵɵFactoryTarget.Injectable });
 FlowStateConfigurationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowStateConfigurationService });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowStateConfigurationService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: i1.FlowInfoService }, { type: i2.FlowConfigurationService }, { type: i3.FlowStateApiService }, { type: i4.FlowStateService }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+        }], ctorParameters: function () { return [{ type: i1.FlowInfoService }, { type: i2.FlowStateService }]; } });
+//# sourceMappingURL=data:application/json;base64,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