@veloceapps/sdk 11.0.0-98 → 12.0.0-0

package/fesm2020/veloceapps-sdk-core.mjs

@@ -146,6 +146,19 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
         }], ctorParameters: function () { return [{ type: i1.ConfigurationSettingsApiService }]; } });
 
 class FlowInfoService {
+    constructor(runtimeSettingsService, templatesAdminApiService, customizationService) {
+        this.runtimeSettingsService = runtimeSettingsService;
+        this.templatesAdminApiService = templatesAdminApiService;
+        this.customizationService = customizationService;
+        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();
+    }
     get flow() {
         if (!this.flowSubj$.value) {
             throw new Error(`Flow not initialized yet`);
@@ -173,19 +186,6 @@ class FlowInfoService {
     get isStateful() {
         return !!this.flow?.properties.stateful;
     }
-    constructor(runtimeSettingsService, templatesAdminApiService, customizationService) {
-        this.runtimeSettingsService = runtimeSettingsService;
-        this.templatesAdminApiService = templatesAdminApiService;
-        this.customizationService = customizationService;
-        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({});
@@ -282,6 +282,21 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
                     args: [FLOW_CUSTOMIZATION]
                 }] }]; } });
 
+class PCMUtils {
+    static mapByPrcId(pcm) {
+        const map = {};
+        if (pcm.productRelatedComponent) {
+            map[pcm.productRelatedComponent.id] = pcm;
+        }
+        for (const group of pcm.productComponentGroups) {
+            for (const gc of group.components) {
+                Object.assign(map, PCMUtils.mapByPrcId(gc));
+            }
+        }
+        return map;
+    }
+}
+
 const findTransactionItem = (id, items) => {
     return findTransactionItemWithComparator(items, (ti) => ti.id === id);
 };
@@ -333,11 +348,86 @@ const replaceTransactionItem = (item, replaceTo) => {
         children: item.children.map(ti => replaceTransactionItem(ti, replaceTo)),
     };
 };
-const generateTransactionItem = (productId) => {
-    return {
-        id: UUID.UUID(),
-        productId,
+const generateTransactionItem = (option, salesTransactionId, qty, parentTi) => {
+    const newItem = generateTransactionItemFromPCM(option, salesTransactionId, parentTi);
+    // propagate Proportional quantities to children
+    const updatedNewItem = updateQuantity(newItem, qty ?? newItem.qty, option, parentTi?.qty);
+    return updatedNewItem;
+};
+const generateTransactionItemFromPCM = (option, salesTransactionId, parentTi) => {
+    const childId = UUID.UUID();
+    const newItem = {
+        id: childId,
+        productId: option.id,
+        productName: option.name,
+        productCode: option.productCode,
+        productRelatedComponentId: option.productRelatedComponent?.id,
+        stiAttributes: [],
+        attributes: {
+            ParentReference: salesTransactionId,
+            ItemPath: option.id,
+            SalesTransactionItemSource: childId,
+            SalesTransactionItemParent: salesTransactionId,
+            ProductSellingModel: option.productSellingModelOptions?.[0]?.productSellingModel.id,
+        },
+        qty: option.productRelatedComponent?.quantity ?? 1,
+    };
+    if (parentTi) {
+        newItem.parentId = parentTi.id;
+    }
+    newItem.children = option.productComponentGroups.reduce((acc, group) => {
+        group.components.forEach(component => {
+            if (component.productRelatedComponent?.isComponentRequired ||
+                component.productRelatedComponent?.isDefaultComponent) {
+                acc.push(generateTransactionItemFromPCM(component, salesTransactionId, newItem));
+            }
+        });
+        return acc;
+    }, []);
+    return newItem;
+};
+const flattenTransactionItem = (ti) => {
+    const result = [];
+    const traverse = (item) => {
+        if (!item)
+            return;
+        result.push(item);
+        if (Array.isArray(item.children) && item.children.length) {
+            for (const child of item.children) {
+                traverse(child);
+            }
+        }
     };
+    traverse(ti);
+    return result;
+};
+const updateQuantity = (ti, qty, pcm, parentQty = 1) => {
+    const pcmMap = PCMUtils.mapByPrcId(pcm);
+    const calcNewQty = (item, parentPrevQty, parentNewQty, parentPcm, inputQty, isDirectChange) => {
+        const scaleMethod = parentPcm?.productRelatedComponent?.quantityScaleMethod;
+        if (isDirectChange) {
+            return scaleMethod === 'Proportional' ? parentPrevQty * inputQty : inputQty;
+        }
+        else {
+            return scaleMethod === 'Proportional' ? (item.qty / parentPrevQty) * parentNewQty : item.qty;
+        }
+    };
+    const updateItem = (item, parentPrevQty, parentNewQty, isDirectChange) => {
+        const pcm = pcmMap[item.productRelatedComponentId];
+        let nextQty = item.qty;
+        if (item.id === ti.id || isDirectChange) {
+            nextQty = calcNewQty(item, parentPrevQty, parentNewQty, pcm, qty, true);
+        }
+        else if (parentPrevQty !== parentNewQty) {
+            nextQty = calcNewQty(item, parentPrevQty, parentNewQty, pcm, qty, false);
+        }
+        return {
+            ...item,
+            qty: nextQty,
+            children: item.children.map(child => updateItem(child, item.qty, nextQty, false)),
+        };
+    };
+    return updateItem(ti, parentQty, parentQty, false);
 };
 
 class TransactionItemWorker {
@@ -378,8 +468,8 @@ class GuidedSellingService {
             orchestrationName: data.orchestrationName,
         })
             .pipe(map(transactionContext => {
-            const guidedSellingNode = transactionContext.childNodes['GuidedSelling']?.[0];
-            const guidedSellingResult = guidedSellingNode?.tagAttributes?.['result'] || {};
+            const guidedSellingNode = transactionContext.nodes['GuidedSelling']?.[0];
+            const guidedSellingResult = guidedSellingNode?.attributes?.['result'] || {};
             this.guidedSellingResult$.next(guidedSellingResult);
             return guidedSellingResult;
         }));
@@ -392,24 +482,24 @@ class GuidedSellingService {
             id: UUID.UUID(),
             businessObjectType: 'Quote',
             salesTransactionItems: [],
-            tagAttributes: {},
+            attributes: {},
         };
         return {
             salesTransaction: testTransaction,
             transactionId: UUID.UUID(),
             businessObjectType: 'Quote',
-            childNodes: {
+            nodes: {
                 GuidedSelling: [
                     {
                         id: UUID.UUID(),
-                        tagAttributes: {},
-                        childNodes: {},
+                        attributes: {},
+                        nodes: {},
                         properties: { guidedSellingAttributes },
                     },
                 ],
             },
             id: UUID.UUID(),
-            tagAttributes: {},
+            attributes: {},
         };
     }
 }
@@ -467,15 +557,13 @@ class ConfigurationService {
             transactionItem = salesTransactionItems.find(item => item.productId === productId);
         }
         if (!transactionItem) {
-            transactionItem = generateTransactionItem(productId);
-            if (typeof newProductQty === 'number' && newProductQty > 0) {
-                transactionItem.qty = newProductQty;
-            }
+            const quantity = typeof newProductQty === 'number' && newProductQty > 0 ? newProductQty : undefined;
+            transactionItem = generateTransactionItem(this.getPCMModel(), this.state?.salesTransaction.id, quantity);
             isRootGenerated = true;
         }
         const guidedSellingResult = this.guidedSellingService.guidedSellingResult;
         if (transactionItem && Object.keys(guidedSellingResult).length && isRootGenerated) {
-            transactionItem.attributes = Object.entries(guidedSellingResult).map(([attributeName, value]) => ({
+            transactionItem.stiAttributes = Object.entries(guidedSellingResult).map(([attributeName, value]) => ({
                 attributeName,
                 value,
             }));
@@ -695,12 +783,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
         }], ctorParameters: function () { return [{ type: i1.OrchestrationsApiService }, { type: SalesTransactionService }, { type: FlowInfoService }]; } });
 
 class TestModeConfigurationService {
-    constructor(flowInfoService, configurationService, configurationRuntimeService, salesTransactionService, runtimeSettingsService) {
+    constructor(flowInfoService, configurationService, configurationRuntimeService, salesTransactionService, runtimeSettingsService, sfApiService) {
         this.flowInfoService = flowInfoService;
         this.configurationService = configurationService;
         this.configurationRuntimeService = configurationRuntimeService;
         this.salesTransactionService = salesTransactionService;
         this.runtimeSettingsService = runtimeSettingsService;
+        this.sfApiService = sfApiService;
         this.isInitialized = false;
     }
     initTestMode$(uiDefinitionContainer, options) {
@@ -720,7 +809,7 @@ class TestModeConfigurationService {
         if (!flowId) {
             return throwError(() => `Unable to start the Configuration Preview: Flow is missing.`);
         }
-        return this.runtimeSettingsService.create().pipe(switchMap(() => this.flowInfoService.init$(flowId, { productId, headerId: quoteId })), switchMap(() => this.configurationRuntimeService.init$({ productId })), tap(pcmModel => (this.pcmModel = pcmModel)), switchMap(() => {
+        return this.runtimeSettingsService.create().pipe(switchMap(() => this.flowInfoService.init$(flowId, { productId, headerId: quoteId, testMode: true })), switchMap(() => this.configurationRuntimeService.init$({ productId })), tap(pcmModel => (this.pcmModel = pcmModel)), switchMap(() => {
             if (options?.customizationMode) {
                 return of(undefined);
             }
@@ -728,35 +817,55 @@ class TestModeConfigurationService {
         }), tap(() => (this.isInitialized = true)), map(noop));
     }
     initConfiguration$(quoteId) {
-        this.salesTransactionService.setState(this.getTestTransactionContext(quoteId));
-        return this.configurationService.init$().pipe(switchMap(() => this.configurationService.state
+        return this.getPriceBookId(quoteId).pipe(map(priceBookId => this.getTestTransactionContext(quoteId, priceBookId)), tap(state => this.salesTransactionService.setState(state)), switchMap(() => this.configurationService.init$()), switchMap(() => this.configurationService.state
             ? this.configurationService.configure$(this.configurationService.state)
             : of(undefined)), map(noop));
     }
-    getTestTransactionContext(quoteId) {
+    getPriceBookId(quoteId) {
+        return this.sfApiService
+            .query({ count: 1, fields: ['Pricebook2Id'], rawCondition: `Id = '${quoteId}'` }, 'Quote')
+            .pipe(map(r => r?.[0]?.Pricebook2Id ?? null));
+    }
+    getTestTransactionContext(quoteId, priceBookId) {
+        const dateStr = new Date().toISOString().split('T')[0] ?? '';
         const testTransaction = {
             id: quoteId,
             businessObjectType: 'Quote',
             salesTransactionItems: [],
+            salesTransactionName: 'Test Quote',
+            account: '',
+            quoteAccount: '',
+            pricebook: '',
+            status: 'Draft',
+            totalAmount: 0,
+            subtotal: 0,
+            activatedDate: dateStr,
+            effectiveDate: dateStr,
+            startDate: dateStr,
+            attributes: {},
+            nodes: {},
         };
+        if (priceBookId) {
+            testTransaction.pricebook = priceBookId;
+        }
         return {
             salesTransaction: testTransaction,
             transactionId: quoteId,
             businessObjectType: 'Quote',
-            childNodes: {},
+            nodes: {},
             id: UUID.UUID(),
-            tagAttributes: {},
+            attributes: {},
         };
     }
     checkInitialized(uiDefinitionContainer) {
         return this.isInitialized && !!uiDefinitionContainer.source.properties?.persistTestState;
     }
 }
-TestModeConfigurationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TestModeConfigurationService, deps: [{ token: FlowInfoService }, { token: ConfigurationService }, { token: ConfigurationRuntimeService }, { token: SalesTransactionService }, { token: RuntimeSettingsService }], target: i0.ɵɵFactoryTarget.Injectable });
+TestModeConfigurationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TestModeConfigurationService, deps: [{ token: FlowInfoService }, { token: ConfigurationService }, { token: ConfigurationRuntimeService }, { token: SalesTransactionService }, { token: RuntimeSettingsService }, { token: i1.SalesforceApiService }], target: i0.ɵɵFactoryTarget.Injectable });
 TestModeConfigurationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TestModeConfigurationService });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TestModeConfigurationService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: FlowInfoService }, { type: ConfigurationService }, { type: ConfigurationRuntimeService }, { type: SalesTransactionService }, { type: RuntimeSettingsService }]; } });
+        }], ctorParameters: function () { return [{ type: FlowInfoService }, { type: ConfigurationService }, { type: ConfigurationRuntimeService }, { type: SalesTransactionService }, { type: RuntimeSettingsService }, { type: i1.SalesforceApiService }]; } });
 
 class FlowStateService {
     constructor(flowConfiguration, flowInfoService, flowStateApiService, processorsApiService, salesTransactionApiService, salesTransactionService, toastService, customizationService) {
@@ -1158,12 +1267,37 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
                 }] }]; } });
 
 class FlowStateConfigurationService {
-    constructor(flowInfoService, flowStateService, configurationService, salesTransactionService, flowConfigurationService) {
+    constructor(flowInfoService, flowStateService, configurationService, salesTransactionService, flowConfigurationService, pcmApiService) {
         this.flowInfoService = flowInfoService;
         this.flowStateService = flowStateService;
         this.configurationService = configurationService;
         this.salesTransactionService = salesTransactionService;
         this.flowConfigurationService = flowConfigurationService;
+        this.pcmApiService = pcmApiService;
+        this.pcmCache = {};
+    }
+    updateQuantity$(props) {
+        const allItems = this.salesTransactionService.state?.salesTransaction?.salesTransactionItems ?? [];
+        const ti = allItems.find(item => item.id === props.id);
+        if (!ti) {
+            return of(undefined);
+        }
+        return this.getPCMProduct$(ti.productId).pipe(map(pcm => updateQuantity(ti, props.qty, pcm)), switchMap(updatedTi => {
+            const state = this.salesTransactionService.state;
+            if (!state) {
+                return of(undefined);
+            }
+            const updatedState = {
+                ...state,
+                salesTransaction: {
+                    ...state.salesTransaction,
+                    salesTransactionItems: state.salesTransaction.salesTransactionItems.map(item => {
+                        return updatedTi.id === item.id ? updatedTi : item;
+                    }),
+                },
+            };
+            return this.flowConfigurationService.calculate$(updatedState);
+        }), switchMap(() => this.flowStateService.executeRequest$({}, true)), map(noop));
     }
     addToCart$(props) {
         let request$;
@@ -1184,47 +1318,57 @@ class FlowStateConfigurationService {
         return request$.pipe(switchMap(() => this.flowStateService.executeRequest$({}, true)), map(noop));
     }
     configureExternal$(props) {
-        const { state } = this.salesTransactionService;
-        if (!state) {
-            return of();
-        }
-        const stateToConfigure = {
-            ...state,
-            salesTransaction: {
-                ...state.salesTransaction,
-                salesTransactionItems: [
-                    {
-                        ...generateTransactionItem(props.productId),
-                        qty: props.qty ?? 1,
-                        attributes: Object.entries(props.attributesMap ?? {}).map(([attributeName, value]) => ({
-                            attributeName,
-                            value,
-                        })),
-                    },
-                ],
-            },
-        };
-        return this.configurationService.justConfigureRequest$(stateToConfigure).pipe(switchMap(configurationResult => {
-            const state = this.salesTransactionService.state;
-            const addedProduct = configurationResult.salesTransaction.salesTransactionItems[0];
-            if (!state || !addedProduct) {
+        return this.getPCMProduct$(props.productId).pipe(switchMap(pcm => {
+            const { state } = this.salesTransactionService;
+            if (!state) {
                 return of();
             }
-            return this.flowConfigurationService.calculate$({
+            const stateToConfigure = {
                 ...state,
                 salesTransaction: {
                     ...state.salesTransaction,
-                    salesTransactionItems: [...state.salesTransaction.salesTransactionItems, addedProduct],
+                    salesTransactionItems: [
+                        {
+                            ...generateTransactionItem(pcm, this.configurationService.state?.salesTransaction.id, props.qty ?? 1),
+                            stiAttributes: Object.entries(props.attributesMap ?? {}).map(([attributeName, value]) => ({
+                                attributeName,
+                                value,
+                            })),
+                        },
+                    ],
                 },
-            });
+            };
+            return this.configurationService.justConfigureRequest$(stateToConfigure).pipe(switchMap(configurationResult => {
+                const state = this.salesTransactionService.state;
+                const addedProduct = configurationResult.salesTransaction.salesTransactionItems[0];
+                if (!state || !addedProduct) {
+                    return of();
+                }
+                return this.flowConfigurationService.calculate$({
+                    ...state,
+                    salesTransaction: {
+                        ...state.salesTransaction,
+                        salesTransactionItems: [...state.salesTransaction.salesTransactionItems, addedProduct],
+                    },
+                });
+            }));
         }));
     }
+    getPCMProduct$(productId) {
+        const cached = this.pcmCache[productId];
+        if (cached) {
+            return of(cached);
+        }
+        return this.pcmApiService
+            .fetchPCMByProductId(productId)
+            .pipe(tap(pcmProduct => (this.pcmCache[productId] = pcmProduct)));
+    }
 }
-FlowStateConfigurationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowStateConfigurationService, deps: [{ token: FlowInfoService }, { token: FlowStateService }, { token: ConfigurationService }, { token: SalesTransactionService }, { token: FlowConfigurationService }], target: i0.ɵɵFactoryTarget.Injectable });
+FlowStateConfigurationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowStateConfigurationService, deps: [{ token: FlowInfoService }, { token: FlowStateService }, { token: ConfigurationService }, { token: SalesTransactionService }, { token: FlowConfigurationService }, { token: i1.PCMApiService }], 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: FlowInfoService }, { type: FlowStateService }, { type: ConfigurationService }, { type: SalesTransactionService }, { type: FlowConfigurationService }]; } });
+        }], ctorParameters: function () { return [{ type: FlowInfoService }, { type: FlowStateService }, { type: ConfigurationService }, { type: SalesTransactionService }, { type: FlowConfigurationService }, { type: i1.PCMApiService }]; } });
 
 class IntegrationState {
     constructor() {
@@ -1306,7 +1450,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
         }] });
 
 class ConfigurationStateService {
-    constructor(configurationRuntimeService, configurationService, flowStateService, flowInfoService, flowConfigurationService, flowStateApiService, salesTransactionService, salesTransactionApiService, toastService) {
+    constructor(configurationRuntimeService, configurationService, flowStateService, flowInfoService, flowConfigurationService, flowStateApiService, salesTransactionService, salesTransactionApiService, toastService, pcmApiService) {
         this.configurationRuntimeService = configurationRuntimeService;
         this.configurationService = configurationService;
         this.flowStateService = flowStateService;
@@ -1316,6 +1460,7 @@ class ConfigurationStateService {
         this.salesTransactionService = salesTransactionService;
         this.salesTransactionApiService = salesTransactionApiService;
         this.toastService = toastService;
+        this.pcmApiService = pcmApiService;
         this.isInitialized$ = new BehaviorSubject(false);
         this.canceledConfiguration$ = new Subject();
         this.NOT_INITIALIZED = Symbol();
@@ -1433,13 +1578,6 @@ class ConfigurationStateService {
             return of({ id: '' });
         }
         const { standalone } = this.flowInfoService.flow.properties;
-        if (standalone) {
-            const request = {
-                transactionContext: state,
-                flowId: this.flowInfoService.flow.id,
-            };
-            return this.salesTransactionApiService.save(request).pipe(switchMap(r => this.flowStateService.executeRequest$({}, true).pipe(map(() => r))), map(id => ({ id })));
-        }
         const transactionContext = this.salesTransactionService.state;
         const configurationRoot = this.configurationService.root;
         if (!transactionContext || !configurationRoot) {
@@ -1461,6 +1599,13 @@ class ConfigurationStateService {
                 salesTransactionItems,
             },
         };
+        if (standalone) {
+            const request = {
+                transactionContext: newState,
+                flowId: this.flowInfoService.flow.id,
+            };
+            return this.salesTransactionApiService.save(request).pipe(switchMap(r => this.flowStateService.executeRequest$({}, true).pipe(map(() => r))), map(id => ({ id })));
+        }
         return this.flowConfigurationService.calculate$(newState).pipe(switchMap(() => this.flowStateService.executeRequest$({}, true)), map(() => ({ id: '' })));
     }
     cancelConfiguration() {
@@ -1488,11 +1633,13 @@ class ConfigurationStateService {
         const container = this.configurationRuntimeService.uiDefinitionContainer;
         let request$;
         if (!transactionItemId) {
-            request$ = this.flowStateApiService.newConfiguration(this.flowStateService.stateId, {
-                transactionItem: generateTransactionItem(productId),
-                actionsOverride: container?.actions?.map(processor => ({ ...processor, ownerId: this.ownerId })),
-                selectorsOverride: container?.selectors?.map(processor => ({ ...processor, ownerId: this.ownerId })),
-            });
+            request$ = this.pcmApiService.fetchPCMByProductId(productId).pipe(switchMap(pcm => {
+                return this.flowStateApiService.newConfiguration(this.flowStateService.stateId || '', {
+                    transactionItem: generateTransactionItem(pcm, this.configurationService.state?.salesTransaction.id),
+                    actionsOverride: container?.actions?.map(processor => ({ ...processor, ownerId: this.ownerId })),
+                    selectorsOverride: container?.selectors?.map(processor => ({ ...processor, ownerId: this.ownerId })),
+                });
+            }));
         }
         else {
             request$ = this.flowStateApiService.startConfiguration(this.flowStateService.stateId, {
@@ -1657,11 +1804,11 @@ class ConfigurationStateService {
         }, { stateId: '', selectors: {} });
     }
 }
-ConfigurationStateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ConfigurationStateService, deps: [{ token: ConfigurationRuntimeService }, { token: ConfigurationService }, { token: FlowStateService }, { token: FlowInfoService }, { token: FlowConfigurationService }, { token: i3.FlowStateApiService }, { token: SalesTransactionService }, { token: i1.SalesTransactionApiService }, { token: i6.ToastService }], target: i0.ɵɵFactoryTarget.Injectable });
+ConfigurationStateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ConfigurationStateService, deps: [{ token: ConfigurationRuntimeService }, { token: ConfigurationService }, { token: FlowStateService }, { token: FlowInfoService }, { token: FlowConfigurationService }, { token: i3.FlowStateApiService }, { token: SalesTransactionService }, { token: i1.SalesTransactionApiService }, { token: i6.ToastService }, { token: i1.PCMApiService }], target: i0.ɵɵFactoryTarget.Injectable });
 ConfigurationStateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ConfigurationStateService });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ConfigurationStateService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: ConfigurationRuntimeService }, { type: ConfigurationService }, { type: FlowStateService }, { type: FlowInfoService }, { type: FlowConfigurationService }, { type: i3.FlowStateApiService }, { type: SalesTransactionService }, { type: i1.SalesTransactionApiService }, { type: i6.ToastService }]; } });
+        }], ctorParameters: function () { return [{ type: ConfigurationRuntimeService }, { type: ConfigurationService }, { type: FlowStateService }, { type: FlowInfoService }, { type: FlowConfigurationService }, { type: i3.FlowStateApiService }, { type: SalesTransactionService }, { type: i1.SalesTransactionApiService }, { type: i6.ToastService }, { type: i1.PCMApiService }]; } });
 
 class ConfigurationModule {
 }
@@ -1922,5 +2069,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { ActionCodePipe, CalendarDirective, CatalogProductsService, ConfigurationRuntimeService, ConfigurationService, ConfigurationStateService, DEFAULT_FORMATTING_SETTINGS, DatePipe, FLOW_CUSTOMIZATION, FORMATTING_SETTINGS_TOKEN, FlowConfigurationService, FlowInfoService, FlowStateConfigurationService, FlowStateService, GuidedSellingService, IntegrationState, NumberPipe, PricePipe, ProductImagesService, RuntimeSettingsService, SalesTransactionService, SdkCoreModule, SdkDirectivesModule, SdkPipesModule, TestModeConfigurationService, TransactionItemWorker, UI_DEFINITION_VERSION, extractMetadata, filterSuccessfulExecute, findTransactionItem, findTransactionItemWithComparator, generateTransactionItem, insertTransactionItem, removeTransactionItem, replaceTransactionItem };
+export { ActionCodePipe, CalendarDirective, CatalogProductsService, ConfigurationRuntimeService, ConfigurationService, ConfigurationStateService, DEFAULT_FORMATTING_SETTINGS, DatePipe, FLOW_CUSTOMIZATION, FORMATTING_SETTINGS_TOKEN, FlowConfigurationService, FlowInfoService, FlowStateConfigurationService, FlowStateService, GuidedSellingService, IntegrationState, NumberPipe, PCMUtils, PricePipe, ProductImagesService, RuntimeSettingsService, SalesTransactionService, SdkCoreModule, SdkDirectivesModule, SdkPipesModule, TestModeConfigurationService, TransactionItemWorker, UI_DEFINITION_VERSION, extractMetadata, filterSuccessfulExecute, findTransactionItem, findTransactionItemWithComparator, flattenTransactionItem, generateTransactionItem, generateTransactionItemFromPCM, insertTransactionItem, removeTransactionItem, replaceTransactionItem, updateQuantity };
 //# sourceMappingURL=veloceapps-sdk-core.mjs.map