@veloceapps/sdk 8.0.0-14 → 8.0.0-140

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

@@ -0,0 +1,466 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { ConfigurationProcessorsApiService, FlowStateApiService, QuoteApiService } from '@veloceapps/api';
+import { ToastService, ToastType } from '@veloceapps/components';
+import { ConfigurationContextMode, ConfigurationProcessorTypes, EntityUtil, isDefined, UITemplateType, UUID, } from '@veloceapps/core';
+import { assign, cloneDeep, flatten } from 'lodash';
+import { BehaviorSubject, combineLatest, filter, finalize, forkJoin, map, noop, of, shareReplay, Subject, switchMap, takeUntil, tap, } from 'rxjs';
+import { FlowConfigurationService } from '../modules';
+import { FLOW_CUSTOMIZATION } from '../types/flow-customization.types';
+import { ContextService } from './context.service';
+import { FlowInfoService } from './flow-info.service';
+import { QuoteDraftService } from './quote-draft.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./context.service";
+import * as i2 from "./quote-draft.service";
+import * as i3 from "./flow-info.service";
+import * as i4 from "../modules";
+import * as i5 from "@veloceapps/api";
+import * as i6 from "@veloceapps/components";
+export class FlowStateService {
+    constructor(contextService, quoteDraftService, flowInfoService, flowConfiguration, processorsApiService, flowStateApiService, quoteApiService, toastService, customizationService) {
+        this.contextService = contextService;
+        this.quoteDraftService = quoteDraftService;
+        this.flowInfoService = flowInfoService;
+        this.flowConfiguration = flowConfiguration;
+        this.processorsApiService = processorsApiService;
+        this.flowStateApiService = flowStateApiService;
+        this.quoteApiService = quoteApiService;
+        this.toastService = toastService;
+        this.customizationService = customizationService;
+        this.NOT_INITIALIZED = Symbol();
+        this.executedFunctions = {};
+        this._hasStatefulUnsavedChanges = false;
+        this.stateId$ = new BehaviorSubject(null);
+        this.processors = {};
+        this.subscriptions = {};
+        this.cleanup$ = new Subject();
+        /*
+          In stateless mode watch QuoteDraft changes and call executeRequest so that
+          all subscriptions get their updates according to updated QuoteDraft
+        */
+        this.isInitialized$()
+            .pipe(filter(Boolean), filter(() => !this.getFlowSafe().properties.stateful), switchMap(() => this.flowConfiguration.updated$), switchMap(() => this.executeRequest$({}, true)))
+            .subscribe();
+        this.charges$ = this.flowInfoService.flow$.pipe(filter(isDefined), switchMap(flow => {
+            if (!flow.properties.stateful) {
+                return this.quoteDraftService.quoteDraft$.pipe(map(quoteDraft => quoteDraft.charges));
+            }
+            else {
+                return this.subscribe$(UITemplateType.FLOW_ENGINE, 'CHARGES', null, {
+                    cold: true,
+                }).pipe(map(response => (response.success ? response.result : {})));
+            }
+        }), filter(isDefined), shareReplay());
+        this.charges$.subscribe();
+        this.pricePlans$ = this.flowInfoService.flow$.pipe(filter(isDefined), switchMap(flow => {
+            if (!flow.properties.stateful) {
+                return this.quoteDraftService.quoteDraft$.pipe(map(quoteDraft => quoteDraft.pricePlans));
+            }
+            else {
+                return this.subscribe$(UITemplateType.FLOW_ENGINE, 'PRICE_PLANS', null, {
+                    cold: true,
+                }).pipe(map(response => (response.success ? response.result : {})));
+            }
+        }), filter(isDefined), shareReplay());
+        this.pricePlans$.subscribe();
+        this.activeMetrics$ = this.flowInfoService.flow$.pipe(filter(isDefined), switchMap(flow => {
+            if (!flow.properties.stateful) {
+                return this.quoteDraftService.quoteDraft$.pipe(map(quoteDraft => quoteDraft.activeMetrics));
+            }
+            else {
+                return this.subscribe$(UITemplateType.FLOW_ENGINE, 'ACTIVE_METRICS', null, {
+                    cold: true,
+                }).pipe(map(response => (response.success ? response.result : [])));
+            }
+        }), filter(isDefined), shareReplay());
+        this.activeMetrics$.subscribe();
+    }
+    init$() {
+        return this.initProcessors$().pipe(switchMap(() => {
+            if (this.getFlowSafe().properties.stateful) {
+                return this.initStateful$();
+            }
+            else {
+                return this.initStateless$();
+            }
+        }));
+    }
+    cleanup() {
+        Object.values(this.subscriptions).forEach(({ data$ }) => data$.complete());
+        this.subscriptions = {};
+        if (this.stateId$.value) {
+            this.flowStateApiService.cancel(this.stateId$.value).subscribe();
+            this.stateId$.next(null);
+        }
+        this.processors = {};
+        this.cleanup$.next();
+    }
+    get hasUnsavedChanges() {
+        return this.getFlowSafe().properties.stateful
+            ? this._hasStatefulUnsavedChanges
+            : this.quoteDraftService.hasUnsavedChanges;
+    }
+    get stateId() {
+        return this.stateId$.value;
+    }
+    isInitialized$() {
+        return combineLatest([this.stateId$, this.quoteDraftService.isInitialized$]).pipe(map(values => values.some(Boolean)));
+    }
+    isInitialized() {
+        return Boolean(this.stateId$.value) || this.quoteDraftService.isInitialized;
+    }
+    execute$(scope, exec) {
+        const request = this.execToRequest(scope, exec);
+        return this.executeRequest$(request).pipe(map(result => {
+            // Keep only requested results
+            const actualSelectors = Object.entries(result.selectors).reduce((trunk, [requestId, result]) => {
+                if (exec.selectors?.[requestId]) {
+                    trunk[requestId] = result;
+                }
+                return trunk;
+            }, {});
+            return actualSelectors;
+        }));
+    }
+    dispatch$(scope, action, inputData) {
+        const exec = {
+            actions: [{ name: action, inputData }],
+        };
+        const request = this.execToRequest(scope, exec);
+        return this.executeRequest$(request).pipe(map(noop));
+    }
+    select$(scope, selectorName, inputData) {
+        const requestId = this.generateRequestId(scope, selectorName, inputData);
+        const request = this.execToRequest(scope, {
+            selectors: {
+                [requestId]: {
+                    name: selectorName,
+                    inputData,
+                },
+            },
+        });
+        return this.executeRequest$(request).pipe(map(response => response.selectors[requestId]));
+    }
+    subscribe$(scope, selectorName, inputData, options) {
+        const requestId = this.generateRequestId(scope, selectorName, inputData);
+        if (!this.subscriptions[requestId]) {
+            const request = this.execToRequest(scope, {
+                selectors: {
+                    [requestId]: {
+                        name: selectorName,
+                        inputData,
+                    },
+                },
+            });
+            this.subscriptions[requestId] = {
+                request,
+                data$: new BehaviorSubject(this.NOT_INITIALIZED),
+            };
+            if (!options?.cold) {
+                this.executeRequest$(request).subscribe();
+            }
+        }
+        return this.subscriptions[requestId].data$.pipe(filter(data => data != this.NOT_INITIALIZED), map(data => data), finalize(() => {
+            if (!this.subscriptions[requestId].data$.observed) {
+                delete this.subscriptions[requestId];
+            }
+        }));
+    }
+    save$() {
+        if (this.getFlowSafe().properties.stateful) {
+            if (this.stateId$.value) {
+                return this.flowStateApiService.save(this.stateId$.value);
+            }
+        }
+        else {
+            const quoteDraft = this.quoteDraftService.quoteDraftForActivePriceList;
+            if (quoteDraft) {
+                return this.quoteApiService.upsertQuote(quoteDraft);
+            }
+        }
+        return of({ quoteId: '' });
+    }
+    submit$() {
+        if (this.getFlowSafe().properties.stateful) {
+            if (this.stateId$.value) {
+                return this.flowStateApiService.submit(this.stateId$.value);
+            }
+        }
+        else {
+            const quoteDraft = this.quoteDraftService.quoteDraftForActivePriceList;
+            if (quoteDraft) {
+                return this.quoteApiService.submitQuote(quoteDraft);
+            }
+        }
+        return of({ quoteId: '' });
+    }
+    getOwnerIdByScope(scope) {
+        const ownerId = this.flowInfoService.templates[scope]?.id;
+        if (!ownerId) {
+            throw `OwnerId is not found for scope ${scope}`;
+        }
+        return ownerId;
+    }
+    getScopeByOwnerId(id) {
+        for (const template of Object.values(this.flowInfoService.templates)) {
+            if (template.id === id) {
+                return template.type;
+            }
+        }
+        return;
+    }
+    execToRequest(scope, exec) {
+        const ownerId = this.getOwnerIdByScope(scope);
+        return {
+            actions: exec.actions?.map(action => ({ apiName: action.name, ownerId, inputData: action.inputData ?? {} })),
+            selectors: exec.selectors &&
+                Object.entries(exec.selectors).reduce((trunk, [key, selector]) => ({
+                    ...trunk,
+                    [key]: { apiName: selector.name, ownerId, inputData: selector.inputData ?? {} },
+                }), {}),
+        };
+    }
+    executeRequest$(request, forceSubscriptions = false) {
+        const fullRequest = cloneDeep(request);
+        if (fullRequest.actions?.length || forceSubscriptions) {
+            for (const subscription of Object.values(this.subscriptions)) {
+                fullRequest.selectors = assign(fullRequest.selectors, subscription.request.selectors);
+            }
+        }
+        const execution$ = this.getFlowSafe().properties.stateful
+            ? this.executeStateful$(fullRequest)
+            : this.executeStateless$(fullRequest);
+        return execution$.pipe(tap(result => this.handleSelectorsResponse(result.selectors)));
+    }
+    handleSelectorsResponse(selectors) {
+        Object.entries(selectors).forEach(([requestId, selectorResult]) => {
+            if (!selectorResult.success) {
+                this.toastService.add({ severity: ToastType.error, summary: selectorResult.errorMessage });
+            }
+            const subscription$ = this.subscriptions[requestId]?.data$;
+            if (subscription$) {
+                subscription$.next(selectorResult);
+            }
+        });
+    }
+    initStateful$() {
+        // Subscriptions
+        this.subscribe$(UITemplateType.FLOW_ENGINE, 'CONTEXT', null, { cold: true })
+            .pipe(tap(response => {
+            if (response.success) {
+                this.contextService.update(response.result);
+            }
+        }), takeUntil(this.cleanup$))
+            .subscribe();
+        const processorsList = flatten(Object.values(this.processors).map(ownerMap => Object.values(ownerMap ?? {})));
+        const processors = processorsList.length ? processorsList : undefined;
+        const selectors = Object.values(this.subscriptions)
+            .map(({ request }) => request.selectors)
+            .filter(isDefined)
+            .reduce((trunk, selectors) => ({ ...trunk, ...selectors }), {});
+        const request = this.getDefaultExecutionRequestDTO();
+        return this.flowStateApiService
+            .init({
+            quoteId: this.contextService.resolve().headerId,
+            params: this.flowInfoService.params ?? {},
+            actionsOverride: processors?.filter(processor => processor.type === ConfigurationProcessorTypes.ACTION),
+            selectorsOverride: processors?.filter(processor => processor.type === ConfigurationProcessorTypes.SELECTOR),
+            selectors: { ...selectors, ...request.selectors },
+            actions: request.actions,
+        })
+            .pipe(map(({ stateId, selectors }) => {
+            this.handleSelectorsResponse(selectors);
+            this.stateId$.next(stateId);
+        }));
+    }
+    executeStateful$(request) {
+        if (!this.stateId$.value) {
+            throw 'Stateful session is not initialized';
+        }
+        return this.flowStateApiService.execute(this.stateId$.value, request).pipe(tap(() => {
+            if (request.actions?.length) {
+                this._hasStatefulUnsavedChanges = true;
+            }
+        }), tap(response => this.stateId$.next(response.stateId)));
+    }
+    initStateless$() {
+        const { headerId } = this.contextService.resolve();
+        return this.quoteDraftService.init(headerId, this.flowInfoService.params ?? {}).pipe(switchMap(() => this.executeRequest$(this.getDefaultExecutionRequestDTO())), switchMap(() => this.calculate$()), tap(() => this.quoteDraftService.finalizeInit()), map(noop));
+    }
+    calculate$() {
+        const flowState = this.quoteDraftService.quoteDraft;
+        if (!flowState) {
+            return of(undefined);
+        }
+        /*
+          Don't execute procedures when:
+            * Initializing a standalone product configuration UI, as procedure is execute in /price call
+            * Initializing an empty account (account with no assets)
+        */
+        const isEmptyAccountMode = this.contextService.mode === ConfigurationContextMode.ACCOUNT &&
+            !this.quoteDraftService.hasProducts &&
+            !this.quoteDraftService.hasAssets &&
+            !this.quoteDraftService.quoteDraft?.initialState.length;
+        if (this.quoteDraftService.isStandalone || isEmptyAccountMode) {
+            return of(undefined);
+        }
+        return this.flowConfiguration.calculate$(flowState);
+    }
+    executeStateless$(request) {
+        return of(undefined).pipe(tap(() => this.executeStatelessActions(request)), switchMap(() => {
+            /*
+              Skip price calculation in case
+              1. No actions in the request
+              2. Initialization process execution (state not initialized yet)
+            */
+            if (!request.actions?.length || !this.isInitialized()) {
+                return of(undefined);
+            }
+            else {
+                return this.calculate$();
+            }
+        }), map(() => this.executeStatelessSelectors(request)));
+    }
+    executeStatelessActions(request) {
+        if (!this.quoteDraftService.quoteDraft || !request.actions?.length) {
+            return;
+        }
+        let flowState = this.quoteDraftService.quoteDraft;
+        request.actions.forEach(action => {
+            try {
+                flowState = this.executeActionScript(flowState, action) ?? flowState;
+            }
+            catch (e) {
+                console.error(e);
+                this.toastService.add({ severity: ToastType.error, summary: String(e) });
+                throw e;
+            }
+        });
+        this.quoteDraftService.updateQuoteDraft(flowState);
+    }
+    executeStatelessSelectors(request) {
+        if (!this.quoteDraftService.quoteDraft) {
+            throw 'QuoteDraft is not initialized';
+        }
+        const flowState = this.quoteDraftService.quoteDraft;
+        return EntityUtil.entries(request.selectors ?? {}).reduce((result, [key, selector]) => {
+            try {
+                result.selectors[key] = {
+                    success: true,
+                    result: this.executeSelectorScript(flowState, selector),
+                };
+            }
+            catch (e) {
+                console.error(e);
+                result.selectors[key] = {
+                    success: false,
+                    errorMessage: String(e),
+                };
+            }
+            return result;
+        }, { stateId: '', selectors: {} });
+    }
+    getFlowSafe() {
+        if (!this.flowInfoService.flow) {
+            throw 'Flow is not defined';
+        }
+        return this.flowInfoService.flow;
+    }
+    initProcessors$() {
+        const hasOverrides = Boolean(this.customizationService?.getTemplateConfigurationProcessors);
+        const flow = this.getFlowSafe();
+        if (flow.properties.stateful && !hasOverrides) {
+            // Skip initialization as backend will take processors from SF
+            return of(undefined);
+        }
+        const owners$ = Object.values(this.flowInfoService.templates)
+            .map(template => {
+            if (!template) {
+                return;
+            }
+            const localProcessors$ = this.customizationService?.getTemplateConfigurationProcessors?.(template.name) ?? of(null);
+            return localProcessors$.pipe(switchMap(processors => processors ? of(processors) : this.processorsApiService.fetchConfigurationProcessors$(template.id)), tap(processors => {
+                const processorsMap = processors.reduce((acc, p) => {
+                    acc[p.apiName] = p;
+                    return acc;
+                }, {});
+                this.processors[template.id] = processorsMap;
+            }));
+        })
+            .filter(isDefined);
+        if (!owners$.length) {
+            return of(undefined);
+        }
+        return forkJoin(owners$).pipe(map(noop));
+    }
+    executeActionScript(request, executable) {
+        const configurationProcessor = this.processors[executable.ownerId]?.[executable.apiName];
+        if (!configurationProcessor?.script) {
+            const scope = this.getScopeByOwnerId(executable.ownerId);
+            const scopeText = scope ? ` in ${scope}` : '';
+            throw `ConfigurationProcessor ${executable.apiName}${scopeText} not found`;
+        }
+        return this.executeProcessorScript(request, configurationProcessor, executable.inputData);
+    }
+    executeSelectorScript(request, executable) {
+        const configurationProcessor = this.processors[executable.ownerId]?.[executable.apiName];
+        if (!configurationProcessor?.script) {
+            const scope = this.getScopeByOwnerId(executable.ownerId);
+            const scopeText = scope ? ` in ${scope}` : '';
+            throw `ConfigurationProcessor ${executable.apiName}${scopeText} not found`;
+        }
+        return this.executeProcessorScript(request, configurationProcessor, executable.inputData);
+    }
+    executeProcessorScript(request, configurationProcessor, inputData) {
+        let functionToExecute = this.executedFunctions[configurationProcessor.apiName];
+        if (!functionToExecute) {
+            functionToExecute = new Function(`${configurationProcessor.script}\nreturn transform;`)();
+            this.executedFunctions[configurationProcessor.apiName] = functionToExecute;
+        }
+        return functionToExecute({
+            request,
+            inputData,
+        });
+    }
+    generateRequestId(scope, selectorName, inputData) {
+        const inputDataHash = UUID.hex(JSON.stringify(inputData) || '').slice(0, 8);
+        return `${scope}/${selectorName}/${inputDataHash}`;
+    }
+    getDefaultExecutionRequestDTO() {
+        const request = {
+            actions: [],
+            selectors: {},
+        };
+        if (this.getFlowSafe().properties.standalone) {
+            return request;
+        }
+        const ownerId = this.getOwnerIdByScope(UITemplateType.FLOW_ENGINE);
+        request.actions?.push({
+            apiName: 'UPDATE_PRICE_LIST',
+            ownerId,
+            inputData: {},
+        });
+        request.actions?.push({
+            apiName: 'UPDATE_ASSET_IDS',
+            ownerId,
+            inputData: {},
+        });
+        request.actions?.push({
+            apiName: 'UPDATE_CONTEXT_PROPERTIES',
+            ownerId,
+            inputData: this.contextService.resolve().properties,
+        });
+        return request;
+    }
+}
+FlowStateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowStateService, deps: [{ token: i1.ContextService }, { token: i2.QuoteDraftService }, { token: i3.FlowInfoService }, { token: i4.FlowConfigurationService }, { token: i5.ConfigurationProcessorsApiService }, { token: i5.FlowStateApiService }, { token: i5.QuoteApiService }, { token: i6.ToastService }, { token: FLOW_CUSTOMIZATION, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+FlowStateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowStateService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowStateService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.ContextService }, { type: i2.QuoteDraftService }, { type: i3.FlowInfoService }, { type: i4.FlowConfigurationService }, { type: i5.ConfigurationProcessorsApiService }, { type: i5.FlowStateApiService }, { type: i5.QuoteApiService }, { type: i6.ToastService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [FLOW_CUSTOMIZATION]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flow-state.service.js","sourceRoot":"","sources":["../../../../../../libs/sdk/core/services/flow-state.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,EAAE,iCAAiC,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAC1G,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAIL,wBAAwB,EAExB,2BAA2B,EAC3B,UAAU,EAQV,SAAS,EAET,cAAc,EACd,IAAI,GACL,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,MAAM,EAAE,SAAS,EAAc,OAAO,EAAE,MAAM,QAAQ,CAAC;AAChE,OAAO,EACL,eAAe,EACf,aAAa,EACb,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,GAAG,EACH,IAAI,EAEJ,EAAE,EACF,WAAW,EACX,OAAO,EACP,SAAS,EACT,SAAS,EACT,GAAG,GACJ,MAAM,MAAM,CAAC;AACd,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,EAAqB,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAE1F,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;;;;;;;;AAc1D,MAAM,OAAO,gBAAgB;IAc3B,YACU,cAA8B,EAC9B,iBAAoC,EACpC,eAAgC,EAChC,iBAA2C,EAC3C,oBAAuD,EACvD,mBAAwC,EACxC,eAAgC,EAChC,YAA0B,EACc,oBAAwC;QARhF,mBAAc,GAAd,cAAc,CAAgB;QAC9B,sBAAiB,GAAjB,iBAAiB,CAAmB;QACpC,oBAAe,GAAf,eAAe,CAAiB;QAChC,sBAAiB,GAAjB,iBAAiB,CAA0B;QAC3C,yBAAoB,GAApB,oBAAoB,CAAmC;QACvD,wBAAmB,GAAnB,mBAAmB,CAAqB;QACxC,oBAAe,GAAf,eAAe,CAAiB;QAChC,iBAAY,GAAZ,YAAY,CAAc;QACc,yBAAoB,GAApB,oBAAoB,CAAoB;QAlBzE,oBAAe,GAAG,MAAM,EAAE,CAAC;QAEpC,sBAAiB,GAAiF,EAAE,CAAC;QACrG,+BAA0B,GAAG,KAAK,CAAC;QACnC,aAAQ,GAAG,IAAI,eAAe,CAAgB,IAAI,CAAC,CAAC;QACpD,eAAU,GAAkB,EAAE,CAAC;QAC/B,kBAAa,GAAiC,EAAE,CAAC;QACjD,aAAQ,GAAG,IAAI,OAAO,EAAQ,CAAC;QAarC;;;UAGE;QACF,IAAI,CAAC,cAAc,EAAE;aAClB,IAAI,CACH,MAAM,CAAC,OAAO,CAAC,EACf,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,EACrD,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,EAChD,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,CAChD;aACA,SAAS,EAAE,CAAC;QAEf,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,IAAI,CAC7C,MAAM,CAAC,SAAS,CAAC,EACjB,SAAS,CAAC,IAAI,CAAC,EAAE;YACf,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE;gBAC7B,OAAO,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC;aACvF;iBAAM;gBACL,OAAO,IAAI,CAAC,UAAU,CAAqB,cAAc,CAAC,WAAW,EAAE,SAAS,EAAE,IAAI,EAAE;oBACtF,IAAI,EAAE,IAAI;iBACX,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;aACrE;QACH,CAAC,CAAC,EACF,MAAM,CAAC,SAAS,CAAC,EACjB,WAAW,EAAE,CACd,CAAC;QACF,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;QAE1B,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,IAAI,CAChD,MAAM,CAAC,SAAS,CAAC,EACjB,SAAS,CAAC,IAAI,CAAC,EAAE;YACf,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE;gBAC7B,OAAO,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC;aAC1F;iBAAM;gBACL,OAAO,IAAI,CAAC,UAAU,CAAgC,cAAc,CAAC,WAAW,EAAE,aAAa,EAAE,IAAI,EAAE;oBACrG,IAAI,EAAE,IAAI;iBACX,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;aACrE;QACH,CAAC,CAAC,EACF,MAAM,CAAC,SAAS,CAAC,EACjB,WAAW,EAAE,CACd,CAAC;QACF,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC;QAE7B,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,IAAI,CACnD,MAAM,CAAC,SAAS,CAAC,EACjB,SAAS,CAAC,IAAI,CAAC,EAAE;YACf,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE;gBAC7B,OAAO,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC,CAAC;aAC7F;iBAAM;gBACL,OAAO,IAAI,CAAC,UAAU,CAAe,cAAc,CAAC,WAAW,EAAE,gBAAgB,EAAE,IAAI,EAAE;oBACvF,IAAI,EAAE,IAAI;iBACX,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;aACrE;QACH,CAAC,CAAC,EACF,MAAM,CAAC,SAAS,CAAC,EACjB,WAAW,EAAE,CACd,CAAC;QACF,IAAI,CAAC,cAAc,CAAC,SAAS,EAAE,CAAC;IAClC,CAAC;IAEM,KAAK;QACV,OAAO,IAAI,CAAC,eAAe,EAAE,CAAC,IAAI,CAChC,SAAS,CAAC,GAAG,EAAE;YACb,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,QAAQ,EAAE;gBAC1C,OAAO,IAAI,CAAC,aAAa,EAAE,CAAC;aAC7B;iBAAM;gBACL,OAAO,IAAI,CAAC,cAAc,EAAE,CAAC;aAC9B;QACH,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAEM,OAAO;QACZ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC3E,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;QAExB,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE;YACvB,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,SAAS,EAAE,CAAC;YACjE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SAC1B;QAED,IAAI,CAAC,UAAU,GAAG,EAAE,CAAC;QACrB,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;IACvB,CAAC;IAED,IAAW,iBAAiB;QAC1B,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,QAAQ;YAC3C,CAAC,CAAC,IAAI,CAAC,0BAA0B;YACjC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,iBAAiB,CAAC;IAC/C,CAAC;IAED,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;IAC7B,CAAC;IAEM,cAAc;QACnB,OAAO,aAAa,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,iBAAiB,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAC/E,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CACpC,CAAC;IACJ,CAAC;IAEM,aAAa;QAClB,OAAO,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC;IAC9E,CAAC;IAEM,QAAQ,CACb,KAAqB,EACrB,IAA+B;QAE/B,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAEhD,OAAO,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,IAAI,CACvC,GAAG,CAAC,MAAM,CAAC,EAAE;YACX,8BAA8B;YAC9B,MAAM,eAAe,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,MAAM,CAC7D,CAAC,KAAgD,EAAE,CAAC,SAAS,EAAE,MAAM,CAAC,EAAE,EAAE;gBACxE,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC,SAAS,CAAC,EAAE;oBAC/B,KAAK,CAAC,SAAS,CAAC,GAAG,MAAM,CAAC;iBAC3B;gBACD,OAAO,KAAK,CAAC;YACf,CAAC,EACD,EAAE,CACH,CAAC;YAEF,OAAO,eAAe,CAAC;QACzB,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAEM,SAAS,CAAC,KAAqB,EAAE,MAAc,EAAE,SAAmB;QACzE,MAAM,IAAI,GAA8B;YACtC,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;SACvC,CAAC;QACF,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAEhD,OAAO,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;IACvD,CAAC;IAEM,OAAO,CACZ,KAAqB,EACrB,YAAoB,EACpB,SAAmB;QAEnB,MAAM,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,YAAY,EAAE,SAAS,CAAC,CAAC;QACzE,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE;YACxC,SAAS,EAAE;gBACT,CAAC,SAAS,CAAC,EAAE;oBACX,IAAI,EAAE,YAAY;oBAClB,SAAS;iBACV;aACF;SACF,CAAC,CAAC;QAEH,OAAO,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,IAAI,CACvC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,SAAS,CAAwC,CAAC,CACtF,CAAC;IACJ,CAAC;IAEM,UAAU,CACf,KAAqB,EACrB,YAAoB,EACpB,SAAmB,EACnB,OAAsC;QAEtC,MAAM,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,YAAY,EAAE,SAAS,CAAC,CAAC;QAEzE,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,EAAE;YAClC,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE;gBACxC,SAAS,EAAE;oBACT,CAAC,SAAS,CAAC,EAAE;wBACX,IAAI,EAAE,YAAY;wBAClB,SAAS;qBACV;iBACF;aACF,CAAC,CAAC;YAEH,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,GAAG;gBAC9B,OAAO;gBACP,KAAK,EAAE,IAAI,eAAe,CAAU,IAAI,CAAC,eAAe,CAAC;aAC1D,CAAC;YAEF,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE;gBAClB,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC;aAC3C;SACF;QAED,OAAO,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,KAAK,CAAC,IAAI,CAC7C,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,IAAI,IAAI,CAAC,eAAe,CAAC,EAC5C,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAA2C,CAAC,EACxD,QAAQ,CAAC,GAAG,EAAE;YACZ,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,KAAK,CAAC,QAAQ,EAAE;gBACjD,OAAO,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;aACtC;QACH,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAEM,KAAK;QACV,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,QAAQ,EAAE;YAC1C,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE;gBACvB,OAAO,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;aAC3D;SACF;aAAM;YACL,MAAM,UAAU,GAAG,IAAI,CAAC,iBAAiB,CAAC,4BAA4B,CAAC;YACvE,IAAI,UAAU,EAAE;gBACd,OAAO,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;aACrD;SACF;QAED,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC;IAC7B,CAAC;IAEM,OAAO;QACZ,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,QAAQ,EAAE;YAC1C,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE;gBACvB,OAAO,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;aAC7D;SACF;aAAM;YACL,MAAM,UAAU,GAAG,IAAI,CAAC,iBAAiB,CAAC,4BAA4B,CAAC;YACvE,IAAI,UAAU,EAAE;gBACd,OAAO,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;aACrD;SACF;QAED,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC;IAC7B,CAAC;IAEO,iBAAiB,CAAC,KAAqB;QAC7C,MAAM,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC;QAC1D,IAAI,CAAC,OAAO,EAAE;YACZ,MAAM,kCAAkC,KAAK,EAAE,CAAC;SACjD;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAEO,iBAAiB,CAAC,EAAU;QAClC,KAAK,MAAM,QAAQ,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,EAAE;YACpE,IAAI,QAAQ,CAAC,EAAE,KAAK,EAAE,EAAE;gBACtB,OAAO,QAAQ,CAAC,IAAI,CAAC;aACtB;SACF;QAED,OAAO;IACT,CAAC;IAEO,aAAa,CAAC,KAAqB,EAAE,IAA+B;QAC1E,MAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;QAE9C,OAAO;YACL,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,IAAI,EAAE,EAAE,CAAC,CAAC;YAC5G,SAAS,EACP,IAAI,CAAC,SAAS;gBACd,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,MAAM,CACnC,CAAC,KAA6C,EAAE,CAAC,GAAG,EAAE,QAAQ,CAAC,EAAE,EAAE,CAAC,CAAC;oBACnE,GAAG,KAAK;oBACR,CAAC,GAAG,CAAC,EAAE,EAAE,OAAO,EAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,CAAC,SAAS,IAAI,EAAE,EAAE;iBAChF,CAAC,EACF,EAAE,CACH;SACJ,CAAC;IACJ,CAAC;IAEM,eAAe,CACpB,OAAqC,EACrC,qBAA8B,KAAK;QAEnC,MAAM,WAAW,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC;QACvC,IAAI,WAAW,CAAC,OAAO,EAAE,MAAM,IAAI,kBAAkB,EAAE;YACrD,KAAK,MAAM,YAAY,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE;gBAC5D,WAAW,CAAC,SAAS,GAAG,MAAM,CAAC,WAAW,CAAC,SAAS,EAAE,YAAY,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;aACvF;SACF;QAED,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,QAAQ;YACvD,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC;YACpC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAC;QAExC,OAAO,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,uBAAuB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IACxF,CAAC;IAEO,uBAAuB,CAAC,SAA6D;QAC3F,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,EAAE,cAAc,CAAC,EAAE,EAAE;YAChE,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE;gBAC3B,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,cAAc,CAAC,YAAY,EAAE,CAAC,CAAC;aAC5F;YAED,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,EAAE,KAAK,CAAC;YAC3D,IAAI,aAAa,EAAE;gBACjB,aAAa,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;aACpC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,aAAa;QACnB,gBAAgB;QAChB,IAAI,CAAC,UAAU,CAAuB,cAAc,CAAC,WAAW,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;aAC/F,IAAI,CACH,GAAG,CAAC,QAAQ,CAAC,EAAE;YACb,IAAI,QAAQ,CAAC,OAAO,EAAE;gBACpB,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;aAC7C;QACH,CAAC,CAAC,EACF,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CACzB;aACA,SAAS,EAAE,CAAC;QAEf,MAAM,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;QAC9G,MAAM,UAAU,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC;QACtE,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC;aAChD,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC;aACvC,MAAM,CAAC,SAAS,CAAC;aACjB,MAAM,CAAC,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,GAAG,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;QAClE,MAAM,OAAO,GAAG,IAAI,CAAC,6BAA6B,EAAE,CAAC;QAErD,OAAO,IAAI,CAAC,mBAAmB;aAC5B,IAAI,CAAC;YACJ,OAAO,EAAE,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC,QAAQ;YAC/C,MAAM,EAAE,IAAI,CAAC,eAAe,CAAC,MAAM,IAAI,EAAE;YACzC,eAAe,EAAE,UAAU,EAAE,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,CAAC,IAAI,KAAK,2BAA2B,CAAC,MAAM,CAAC;YACvG,iBAAiB,EAAE,UAAU,EAAE,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,CAAC,IAAI,KAAK,2BAA2B,CAAC,QAAQ,CAAC;YAC3G,SAAS,EAAE,EAAE,GAAG,SAAS,EAAE,GAAG,OAAO,CAAC,SAAS,EAAE;YACjD,OAAO,EAAE,OAAO,CAAC,OAAO;SACzB,CAAC;aACD,IAAI,CACH,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,EAAE;YAC7B,IAAI,CAAC,uBAAuB,CAAC,SAAS,CAAC,CAAC;YACxC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC9B,CAAC,CAAC,CACH,CAAC;IACN,CAAC;IAEO,gBAAgB,CAAC,OAAqC;QAC5D,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE;YACxB,MAAM,qCAAqC,CAAC;SAC7C;QAED,OAAO,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,IAAI,CACxE,GAAG,CAAC,GAAG,EAAE;YACP,IAAI,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE;gBAC3B,IAAI,CAAC,0BAA0B,GAAG,IAAI,CAAC;aACxC;QACH,CAAC,CAAC,EACF,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CACtD,CAAC;IACJ,CAAC;IAEO,cAAc;QACpB,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC;QAEnD,OAAO,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,eAAe,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,IAAI,CAClF,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,6BAA6B,EAAE,CAAC,CAAC,EAC3E,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,EAClC,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,YAAY,EAAE,CAAC,EAChD,GAAG,CAAC,IAAI,CAAC,CACV,CAAC;IACJ,CAAC;IAEO,UAAU;QAChB,MAAM,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC;QACpD,IAAI,CAAC,SAAS,EAAE;YACd,OAAO,EAAE,CAAC,SAAS,CAAC,CAAC;SACtB;QAED;;;;UAIE;QACF,MAAM,kBAAkB,GACtB,IAAI,CAAC,cAAc,CAAC,IAAI,KAAK,wBAAwB,CAAC,OAAO;YAC7D,CAAC,IAAI,CAAC,iBAAiB,CAAC,WAAW;YACnC,CAAC,IAAI,CAAC,iBAAiB,CAAC,SAAS;YACjC,CAAC,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,YAAY,CAAC,MAAM,CAAC;QAE1D,IAAI,IAAI,CAAC,iBAAiB,CAAC,YAAY,IAAI,kBAAkB,EAAE;YAC7D,OAAO,EAAE,CAAC,SAAS,CAAC,CAAC;SACtB;QAED,OAAO,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;IACtD,CAAC;IAEO,iBAAiB,CAAC,OAAqC;QAC7D,OAAO,EAAE,CAAC,SAAS,CAAC,CAAC,IAAI,CACvB,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAC,EAChD,SAAS,CAAC,GAAG,EAAE;YACb;;;;cAIE;YACF,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,EAAE;gBACrD,OAAO,EAAE,CAAC,SAAS,CAAC,CAAC;aACtB;iBAAM;gBACL,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC;aAC1B;QACH,CAAC,CAAC,EACF,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,yBAAyB,CAAC,OAAO,CAAC,CAAC,CACnD,CAAC;IACJ,CAAC;IAEO,uBAAuB,CAAC,OAAqC;QACnE,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,UAAU,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE;YAClE,OAAO;SACR;QAED,IAAI,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC;QAClD,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;YAC/B,IAAI;gBACF,SAAS,GAAG,IAAI,CAAC,mBAAmB,CAAC,SAAS,EAAE,MAAM,CAAC,IAAI,SAAS,CAAC;aACtE;YAAC,OAAO,CAAC,EAAE;gBACV,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBACjB,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;gBACzE,MAAM,CAAC,CAAC;aACT;QACH,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC;IACrD,CAAC;IAEO,yBAAyB,CAAC,OAAqC;QACrE,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE;YACtC,MAAM,+BAA+B,CAAC;SACvC;QAED,MAAM,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC;QACpD,OAAO,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC,MAAM,CACvD,CAAC,MAAgC,EAAE,CAAC,GAAG,EAAE,QAAQ,CAAC,EAAE,EAAE;YACpD,IAAI;gBACF,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG;oBACtB,OAAO,EAAE,IAAI;oBACb,MAAM,EAAE,IAAI,CAAC,qBAAqB,CAAC,SAAS,EAAE,QAAQ,CAAC;iBACxD,CAAC;aACH;YAAC,OAAO,CAAC,EAAE;gBACV,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBACjB,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG;oBACtB,OAAO,EAAE,KAAK;oBACd,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC;iBACxB,CAAC;aACH;YAED,OAAO,MAAM,CAAC;QAChB,CAAC,EACD,EAAE,OAAO,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,CAC/B,CAAC;IACJ,CAAC;IAEO,WAAW;QACjB,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE;YAC9B,MAAM,qBAAqB,CAAC;SAC7B;QAED,OAAO,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC;IACnC,CAAC;IAEO,eAAe;QACrB,MAAM,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,oBAAoB,EAAE,kCAAkC,CAAC,CAAC;QAC5F,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QAEhC,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,IAAI,CAAC,YAAY,EAAE;YAC7C,8DAA8D;YAC9D,OAAO,EAAE,CAAC,SAAS,CAAC,CAAC;SACtB;QAED,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC;aAC1D,GAAG,CAAC,QAAQ,CAAC,EAAE;YACd,IAAI,CAAC,QAAQ,EAAE;gBACb,OAAO;aACR;YAED,MAAM,gBAAgB,GACpB,IAAI,CAAC,oBAAoB,EAAE,kCAAkC,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,CAAC;YAE7F,OAAO,gBAAgB,CAAC,IAAI,CAC1B,SAAS,CAAC,UAAU,CAAC,EAAE,CACrB,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC,6BAA6B,CAAC,QAAQ,CAAC,EAAE,CAAC,CACnG,EACD,GAAG,CAAC,UAAU,CAAC,EAAE;gBACf,MAAM,aAAa,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,GAA2C,EAAE,CAAC,EAAE,EAAE;oBACzF,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;oBACnB,OAAO,GAAG,CAAC;gBACb,CAAC,EAAE,EAAE,CAAC,CAAC;gBAEP,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC;YAC/C,CAAC,CAAC,CACH,CAAC;QACJ,CAAC,CAAC;aACD,MAAM,CAAC,SAAS,CAAC,CAAC;QAErB,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;YACnB,OAAO,EAAE,CAAC,SAAS,CAAC,CAAC;SACtB;QAED,OAAO,QAAQ,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;IAC3C,CAAC;IAEO,mBAAmB,CAAC,OAAkB,EAAE,UAAkC;QAChF,MAAM,sBAAsB,GAAG,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QAEzF,IAAI,CAAC,sBAAsB,EAAE,MAAM,EAAE;YACnC,MAAM,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;YACzD,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC9C,MAAM,0BAA0B,UAAU,CAAC,OAAO,GAAG,SAAS,YAAY,CAAC;SAC5E;QAED,OAAO,IAAI,CAAC,sBAAsB,CAAC,OAAO,EAAE,sBAAsB,EAAE,UAAU,CAAC,SAAS,CAAc,CAAC;IACzG,CAAC;IAEO,qBAAqB,CAAC,OAAkB,EAAE,UAAkC;QAClF,MAAM,sBAAsB,GAAG,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QAEzF,IAAI,CAAC,sBAAsB,EAAE,MAAM,EAAE;YACnC,MAAM,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;YACzD,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC9C,MAAM,0BAA0B,UAAU,CAAC,OAAO,GAAG,SAAS,YAAY,CAAC;SAC5E;QAED,OAAO,IAAI,CAAC,sBAAsB,CAAC,OAAO,EAAE,sBAAsB,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC;IAC5F,CAAC;IAEO,sBAAsB,CAC5B,OAAkB,EAClB,sBAA8C,EAC9C,SAAkB;QAElB,IAAI,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC,sBAAsB,CAAC,OAAO,CAAC,CAAC;QAC/E,IAAI,CAAC,iBAAiB,EAAE;YACtB,iBAAiB,GAAG,IAAI,QAAQ,CAAC,GAAG,sBAAsB,CAAC,MAAM,qBAAqB,CAAC,EAAE,CAAC;YAC1F,IAAI,CAAC,iBAAiB,CAAC,sBAAsB,CAAC,OAAO,CAAC,GAAG,iBAAiB,CAAC;SAC5E;QAED,OAAO,iBAAiB,CAAC;YACvB,OAAO;YACP,SAAS;SACV,CAAC,CAAC;IACL,CAAC;IAEO,iBAAiB,CAAC,KAAqB,EAAE,YAAoB,EAAE,SAAmB;QACxF,MAAM,aAAa,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAC5E,OAAO,GAAG,KAAK,IAAI,YAAY,IAAI,aAAa,EAAE,CAAC;IACrD,CAAC;IAEO,6BAA6B;QACnC,MAAM,OAAO,GAAiC;YAC5C,OAAO,EAAE,EAAE;YACX,SAAS,EAAE,EAAE;SACd,CAAC;QAEF,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,UAAU,EAAE;YAC5C,OAAO,OAAO,CAAC;SAChB;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;QAEnE,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC;YACpB,OAAO,EAAE,mBAAmB;YAC5B,OAAO;YACP,SAAS,EAAE,EAAE;SACd,CAAC,CAAC;QACH,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC;YACpB,OAAO,EAAE,kBAAkB;YAC3B,OAAO;YACP,SAAS,EAAE,EAAE;SACd,CAAC,CAAC;QAEH,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC;YACpB,OAAO,EAAE,2BAA2B;YACpC,OAAO;YACP,SAAS,EAAE,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC,UAAU;SACpD,CAAC,CAAC;QAEH,OAAO,OAAO,CAAC;IACjB,CAAC;;6GAvlBU,gBAAgB,uSAuBL,kBAAkB;iHAvB7B,gBAAgB;2FAAhB,gBAAgB;kBAD5B,UAAU;;0BAwBN,QAAQ;;0BAAI,MAAM;2BAAC,kBAAkB","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core';\nimport { ConfigurationProcessorsApiService, FlowStateApiService, QuoteApiService } from '@veloceapps/api';\nimport { ToastService, ToastType } from '@veloceapps/components';\nimport {\n  Charge,\n  CompiledPricePlan,\n  ConfigurationContext,\n  ConfigurationContextMode,\n  ConfigurationProcessor,\n  ConfigurationProcessorTypes,\n  EntityUtil,\n  Flow,\n  FlowState,\n  FlowStateExecutableDTO,\n  FlowStateExecutionRequest,\n  FlowStateExecutionRequestDTO,\n  FlowStateExecutionResult,\n  FlowStateSelectorResponse,\n  isDefined,\n  MetricRule,\n  UITemplateType,\n  UUID,\n} from '@veloceapps/core';\nimport { assign, cloneDeep, Dictionary, flatten } from 'lodash';\nimport {\n  BehaviorSubject,\n  combineLatest,\n  filter,\n  finalize,\n  forkJoin,\n  map,\n  noop,\n  Observable,\n  of,\n  shareReplay,\n  Subject,\n  switchMap,\n  takeUntil,\n  tap,\n} from 'rxjs';\nimport { FlowConfigurationService } from '../modules';\nimport { FlowCustomization, FLOW_CUSTOMIZATION } from '../types/flow-customization.types';\nimport { FlowStateSubscriptionOptions } from '../types/flow-state.types';\nimport { ContextService } from './context.service';\nimport { FlowInfoService } from './flow-info.service';\nimport { QuoteDraftService } from './quote-draft.service';\n\ntype ProcessorsMap = Partial<{\n  [ownerId: string]: {\n    [apiName: string]: ConfigurationProcessor;\n  };\n}>;\n\ntype Subscription = {\n  request: FlowStateExecutionRequestDTO;\n  data$: BehaviorSubject<unknown>;\n};\n\n@Injectable()\nexport class FlowStateService {\n  public charges$: Observable<Dictionary<Charge>>;\n  public pricePlans$: Observable<Dictionary<CompiledPricePlan>>;\n  public activeMetrics$: Observable<MetricRule[]>;\n\n  private readonly NOT_INITIALIZED = Symbol();\n\n  private executedFunctions: Dictionary<(payload: { request: FlowState; inputData: unknown }) => unknown> = {};\n  private _hasStatefulUnsavedChanges = false;\n  private stateId$ = new BehaviorSubject<string | null>(null);\n  private processors: ProcessorsMap = {};\n  private subscriptions: Record<string, Subscription> = {};\n  private cleanup$ = new Subject<void>();\n\n  constructor(\n    private contextService: ContextService,\n    private quoteDraftService: QuoteDraftService,\n    private flowInfoService: FlowInfoService,\n    private flowConfiguration: FlowConfigurationService,\n    private processorsApiService: ConfigurationProcessorsApiService,\n    private flowStateApiService: FlowStateApiService,\n    private quoteApiService: QuoteApiService,\n    private toastService: ToastService,\n    @Optional() @Inject(FLOW_CUSTOMIZATION) private customizationService?: FlowCustomization,\n  ) {\n    /*\n      In stateless mode watch QuoteDraft changes and call executeRequest so that\n      all subscriptions get their updates according to updated QuoteDraft\n    */\n    this.isInitialized$()\n      .pipe(\n        filter(Boolean),\n        filter(() => !this.getFlowSafe().properties.stateful),\n        switchMap(() => this.flowConfiguration.updated$),\n        switchMap(() => this.executeRequest$({}, true)),\n      )\n      .subscribe();\n\n    this.charges$ = this.flowInfoService.flow$.pipe(\n      filter(isDefined),\n      switchMap(flow => {\n        if (!flow.properties.stateful) {\n          return this.quoteDraftService.quoteDraft$.pipe(map(quoteDraft => quoteDraft.charges));\n        } else {\n          return this.subscribe$<Dictionary<Charge>>(UITemplateType.FLOW_ENGINE, 'CHARGES', null, {\n            cold: true,\n          }).pipe(map(response => (response.success ? response.result : {})));\n        }\n      }),\n      filter(isDefined),\n      shareReplay(),\n    );\n    this.charges$.subscribe();\n\n    this.pricePlans$ = this.flowInfoService.flow$.pipe(\n      filter(isDefined),\n      switchMap(flow => {\n        if (!flow.properties.stateful) {\n          return this.quoteDraftService.quoteDraft$.pipe(map(quoteDraft => quoteDraft.pricePlans));\n        } else {\n          return this.subscribe$<Dictionary<CompiledPricePlan>>(UITemplateType.FLOW_ENGINE, 'PRICE_PLANS', null, {\n            cold: true,\n          }).pipe(map(response => (response.success ? response.result : {})));\n        }\n      }),\n      filter(isDefined),\n      shareReplay(),\n    );\n    this.pricePlans$.subscribe();\n\n    this.activeMetrics$ = this.flowInfoService.flow$.pipe(\n      filter(isDefined),\n      switchMap(flow => {\n        if (!flow.properties.stateful) {\n          return this.quoteDraftService.quoteDraft$.pipe(map(quoteDraft => quoteDraft.activeMetrics));\n        } else {\n          return this.subscribe$<MetricRule[]>(UITemplateType.FLOW_ENGINE, 'ACTIVE_METRICS', null, {\n            cold: true,\n          }).pipe(map(response => (response.success ? response.result : [])));\n        }\n      }),\n      filter(isDefined),\n      shareReplay(),\n    );\n    this.activeMetrics$.subscribe();\n  }\n\n  public init$(): Observable<void> {\n    return this.initProcessors$().pipe(\n      switchMap(() => {\n        if (this.getFlowSafe().properties.stateful) {\n          return this.initStateful$();\n        } else {\n          return this.initStateless$();\n        }\n      }),\n    );\n  }\n\n  public cleanup(): void {\n    Object.values(this.subscriptions).forEach(({ data$ }) => data$.complete());\n    this.subscriptions = {};\n\n    if (this.stateId$.value) {\n      this.flowStateApiService.cancel(this.stateId$.value).subscribe();\n      this.stateId$.next(null);\n    }\n\n    this.processors = {};\n    this.cleanup$.next();\n  }\n\n  public get hasUnsavedChanges(): boolean {\n    return this.getFlowSafe().properties.stateful\n      ? this._hasStatefulUnsavedChanges\n      : this.quoteDraftService.hasUnsavedChanges;\n  }\n\n  public get stateId(): string | null {\n    return this.stateId$.value;\n  }\n\n  public isInitialized$(): Observable<boolean> {\n    return combineLatest([this.stateId$, this.quoteDraftService.isInitialized$]).pipe(\n      map(values => values.some(Boolean)),\n    );\n  }\n\n  public isInitialized(): boolean {\n    return Boolean(this.stateId$.value) || this.quoteDraftService.isInitialized;\n  }\n\n  public execute$(\n    scope: UITemplateType,\n    exec: FlowStateExecutionRequest,\n  ): Observable<FlowStateExecutionResult['selectors']> {\n    const request = this.execToRequest(scope, exec);\n\n    return this.executeRequest$(request).pipe(\n      map(result => {\n        // Keep only requested results\n        const actualSelectors = Object.entries(result.selectors).reduce(\n          (trunk: Record<string, FlowStateSelectorResponse>, [requestId, result]) => {\n            if (exec.selectors?.[requestId]) {\n              trunk[requestId] = result;\n            }\n            return trunk;\n          },\n          {},\n        );\n\n        return actualSelectors;\n      }),\n    );\n  }\n\n  public dispatch$(scope: UITemplateType, action: string, inputData?: unknown): Observable<void> {\n    const exec: FlowStateExecutionRequest = {\n      actions: [{ name: action, inputData }],\n    };\n    const request = this.execToRequest(scope, exec);\n\n    return this.executeRequest$(request).pipe(map(noop));\n  }\n\n  public select$<Response = unknown>(\n    scope: UITemplateType,\n    selectorName: string,\n    inputData?: unknown,\n  ): Observable<FlowStateSelectorResponse<Response>> {\n    const requestId = this.generateRequestId(scope, selectorName, inputData);\n    const request = this.execToRequest(scope, {\n      selectors: {\n        [requestId]: {\n          name: selectorName,\n          inputData,\n        },\n      },\n    });\n\n    return this.executeRequest$(request).pipe(\n      map(response => response.selectors[requestId] as FlowStateSelectorResponse<Response>),\n    );\n  }\n\n  public subscribe$<Response = unknown>(\n    scope: UITemplateType,\n    selectorName: string,\n    inputData?: unknown,\n    options?: FlowStateSubscriptionOptions,\n  ): Observable<FlowStateSelectorResponse<Response>> {\n    const requestId = this.generateRequestId(scope, selectorName, inputData);\n\n    if (!this.subscriptions[requestId]) {\n      const request = this.execToRequest(scope, {\n        selectors: {\n          [requestId]: {\n            name: selectorName,\n            inputData,\n          },\n        },\n      });\n\n      this.subscriptions[requestId] = {\n        request,\n        data$: new BehaviorSubject<unknown>(this.NOT_INITIALIZED),\n      };\n\n      if (!options?.cold) {\n        this.executeRequest$(request).subscribe();\n      }\n    }\n\n    return this.subscriptions[requestId].data$.pipe(\n      filter(data => data != this.NOT_INITIALIZED),\n      map(data => data as FlowStateSelectorResponse<Response>),\n      finalize(() => {\n        if (!this.subscriptions[requestId].data$.observed) {\n          delete this.subscriptions[requestId];\n        }\n      }),\n    );\n  }\n\n  public save$(): Observable<{ quoteId: string }> {\n    if (this.getFlowSafe().properties.stateful) {\n      if (this.stateId$.value) {\n        return this.flowStateApiService.save(this.stateId$.value);\n      }\n    } else {\n      const quoteDraft = this.quoteDraftService.quoteDraftForActivePriceList;\n      if (quoteDraft) {\n        return this.quoteApiService.upsertQuote(quoteDraft);\n      }\n    }\n\n    return of({ quoteId: '' });\n  }\n\n  public submit$(): Observable<{ quoteId: string }> {\n    if (this.getFlowSafe().properties.stateful) {\n      if (this.stateId$.value) {\n        return this.flowStateApiService.submit(this.stateId$.value);\n      }\n    } else {\n      const quoteDraft = this.quoteDraftService.quoteDraftForActivePriceList;\n      if (quoteDraft) {\n        return this.quoteApiService.submitQuote(quoteDraft);\n      }\n    }\n\n    return of({ quoteId: '' });\n  }\n\n  private getOwnerIdByScope(scope: UITemplateType): string {\n    const ownerId = this.flowInfoService.templates[scope]?.id;\n    if (!ownerId) {\n      throw `OwnerId is not found for scope ${scope}`;\n    }\n\n    return ownerId;\n  }\n\n  private getScopeByOwnerId(id: string): UITemplateType | undefined {\n    for (const template of Object.values(this.flowInfoService.templates)) {\n      if (template.id === id) {\n        return template.type;\n      }\n    }\n\n    return;\n  }\n\n  private execToRequest(scope: UITemplateType, exec: FlowStateExecutionRequest): FlowStateExecutionRequestDTO {\n    const ownerId = this.getOwnerIdByScope(scope);\n\n    return {\n      actions: exec.actions?.map(action => ({ apiName: action.name, ownerId, inputData: action.inputData ?? {} })),\n      selectors:\n        exec.selectors &&\n        Object.entries(exec.selectors).reduce(\n          (trunk: Record<string, FlowStateExecutableDTO>, [key, selector]) => ({\n            ...trunk,\n            [key]: { apiName: selector.name, ownerId, inputData: selector.inputData ?? {} },\n          }),\n          {},\n        ),\n    };\n  }\n\n  public executeRequest$(\n    request: FlowStateExecutionRequestDTO,\n    forceSubscriptions: boolean = false,\n  ): Observable<FlowStateExecutionResult> {\n    const fullRequest = cloneDeep(request);\n    if (fullRequest.actions?.length || forceSubscriptions) {\n      for (const subscription of Object.values(this.subscriptions)) {\n        fullRequest.selectors = assign(fullRequest.selectors, subscription.request.selectors);\n      }\n    }\n\n    const execution$ = this.getFlowSafe().properties.stateful\n      ? this.executeStateful$(fullRequest)\n      : this.executeStateless$(fullRequest);\n\n    return execution$.pipe(tap(result => this.handleSelectorsResponse(result.selectors)));\n  }\n\n  private handleSelectorsResponse(selectors: Record<string, FlowStateSelectorResponse<unknown>>): void {\n    Object.entries(selectors).forEach(([requestId, selectorResult]) => {\n      if (!selectorResult.success) {\n        this.toastService.add({ severity: ToastType.error, summary: selectorResult.errorMessage });\n      }\n\n      const subscription$ = this.subscriptions[requestId]?.data$;\n      if (subscription$) {\n        subscription$.next(selectorResult);\n      }\n    });\n  }\n\n  private initStateful$(): Observable<void> {\n    // Subscriptions\n    this.subscribe$<ConfigurationContext>(UITemplateType.FLOW_ENGINE, 'CONTEXT', null, { cold: true })\n      .pipe(\n        tap(response => {\n          if (response.success) {\n            this.contextService.update(response.result);\n          }\n        }),\n        takeUntil(this.cleanup$),\n      )\n      .subscribe();\n\n    const processorsList = flatten(Object.values(this.processors).map(ownerMap => Object.values(ownerMap ?? {})));\n    const processors = processorsList.length ? processorsList : undefined;\n    const selectors = Object.values(this.subscriptions)\n      .map(({ request }) => request.selectors)\n      .filter(isDefined)\n      .reduce((trunk, selectors) => ({ ...trunk, ...selectors }), {});\n    const request = this.getDefaultExecutionRequestDTO();\n\n    return this.flowStateApiService\n      .init({\n        quoteId: this.contextService.resolve().headerId,\n        params: this.flowInfoService.params ?? {},\n        actionsOverride: processors?.filter(processor => processor.type === ConfigurationProcessorTypes.ACTION),\n        selectorsOverride: processors?.filter(processor => processor.type === ConfigurationProcessorTypes.SELECTOR),\n        selectors: { ...selectors, ...request.selectors },\n        actions: request.actions,\n      })\n      .pipe(\n        map(({ stateId, selectors }) => {\n          this.handleSelectorsResponse(selectors);\n          this.stateId$.next(stateId);\n        }),\n      );\n  }\n\n  private executeStateful$(request: FlowStateExecutionRequestDTO): Observable<FlowStateExecutionResult> {\n    if (!this.stateId$.value) {\n      throw 'Stateful session is not initialized';\n    }\n\n    return this.flowStateApiService.execute(this.stateId$.value, request).pipe(\n      tap(() => {\n        if (request.actions?.length) {\n          this._hasStatefulUnsavedChanges = true;\n        }\n      }),\n      tap(response => this.stateId$.next(response.stateId)),\n    );\n  }\n\n  private initStateless$(): Observable<void> {\n    const { headerId } = this.contextService.resolve();\n\n    return this.quoteDraftService.init(headerId, this.flowInfoService.params ?? {}).pipe(\n      switchMap(() => this.executeRequest$(this.getDefaultExecutionRequestDTO())),\n      switchMap(() => this.calculate$()),\n      tap(() => this.quoteDraftService.finalizeInit()),\n      map(noop),\n    );\n  }\n\n  private calculate$(): Observable<void> {\n    const flowState = this.quoteDraftService.quoteDraft;\n    if (!flowState) {\n      return of(undefined);\n    }\n\n    /*\n      Don't execute procedures when:\n        * Initializing a standalone product configuration UI, as procedure is execute in /price call\n        * Initializing an empty account (account with no assets)\n    */\n    const isEmptyAccountMode =\n      this.contextService.mode === ConfigurationContextMode.ACCOUNT &&\n      !this.quoteDraftService.hasProducts &&\n      !this.quoteDraftService.hasAssets &&\n      !this.quoteDraftService.quoteDraft?.initialState.length;\n\n    if (this.quoteDraftService.isStandalone || isEmptyAccountMode) {\n      return of(undefined);\n    }\n\n    return this.flowConfiguration.calculate$(flowState);\n  }\n\n  private executeStateless$(request: FlowStateExecutionRequestDTO): Observable<FlowStateExecutionResult> {\n    return of(undefined).pipe(\n      tap(() => this.executeStatelessActions(request)),\n      switchMap(() => {\n        /*\n          Skip price calculation in case\n          1. No actions in the request\n          2. Initialization process execution (state not initialized yet)\n        */\n        if (!request.actions?.length || !this.isInitialized()) {\n          return of(undefined);\n        } else {\n          return this.calculate$();\n        }\n      }),\n      map(() => this.executeStatelessSelectors(request)),\n    );\n  }\n\n  private executeStatelessActions(request: FlowStateExecutionRequestDTO): void {\n    if (!this.quoteDraftService.quoteDraft || !request.actions?.length) {\n      return;\n    }\n\n    let flowState = this.quoteDraftService.quoteDraft;\n    request.actions.forEach(action => {\n      try {\n        flowState = this.executeActionScript(flowState, action) ?? flowState;\n      } catch (e) {\n        console.error(e);\n        this.toastService.add({ severity: ToastType.error, summary: String(e) });\n        throw e;\n      }\n    });\n\n    this.quoteDraftService.updateQuoteDraft(flowState);\n  }\n\n  private executeStatelessSelectors(request: FlowStateExecutionRequestDTO): FlowStateExecutionResult {\n    if (!this.quoteDraftService.quoteDraft) {\n      throw 'QuoteDraft is not initialized';\n    }\n\n    const flowState = this.quoteDraftService.quoteDraft;\n    return EntityUtil.entries(request.selectors ?? {}).reduce(\n      (result: FlowStateExecutionResult, [key, selector]) => {\n        try {\n          result.selectors[key] = {\n            success: true,\n            result: this.executeSelectorScript(flowState, selector),\n          };\n        } catch (e) {\n          console.error(e);\n          result.selectors[key] = {\n            success: false,\n            errorMessage: String(e),\n          };\n        }\n\n        return result;\n      },\n      { stateId: '', selectors: {} },\n    );\n  }\n\n  private getFlowSafe(): Flow {\n    if (!this.flowInfoService.flow) {\n      throw 'Flow is not defined';\n    }\n\n    return this.flowInfoService.flow;\n  }\n\n  private initProcessors$(): Observable<void> {\n    const hasOverrides = Boolean(this.customizationService?.getTemplateConfigurationProcessors);\n    const flow = this.getFlowSafe();\n\n    if (flow.properties.stateful && !hasOverrides) {\n      // Skip initialization as backend will take processors from SF\n      return of(undefined);\n    }\n\n    const owners$ = Object.values(this.flowInfoService.templates)\n      .map(template => {\n        if (!template) {\n          return;\n        }\n\n        const localProcessors$ =\n          this.customizationService?.getTemplateConfigurationProcessors?.(template.name) ?? of(null);\n\n        return localProcessors$.pipe(\n          switchMap(processors =>\n            processors ? of(processors) : this.processorsApiService.fetchConfigurationProcessors$(template.id),\n          ),\n          tap(processors => {\n            const processorsMap = processors.reduce((acc: Record<string, ConfigurationProcessor>, p) => {\n              acc[p.apiName] = p;\n              return acc;\n            }, {});\n\n            this.processors[template.id] = processorsMap;\n          }),\n        );\n      })\n      .filter(isDefined);\n\n    if (!owners$.length) {\n      return of(undefined);\n    }\n\n    return forkJoin(owners$).pipe(map(noop));\n  }\n\n  private executeActionScript(request: FlowState, executable: FlowStateExecutableDTO): FlowState | null {\n    const configurationProcessor = this.processors[executable.ownerId]?.[executable.apiName];\n\n    if (!configurationProcessor?.script) {\n      const scope = this.getScopeByOwnerId(executable.ownerId);\n      const scopeText = scope ? ` in ${scope}` : '';\n      throw `ConfigurationProcessor ${executable.apiName}${scopeText} not found`;\n    }\n\n    return this.executeProcessorScript(request, configurationProcessor, executable.inputData) as FlowState;\n  }\n\n  private executeSelectorScript(request: FlowState, executable: FlowStateExecutableDTO): unknown {\n    const configurationProcessor = this.processors[executable.ownerId]?.[executable.apiName];\n\n    if (!configurationProcessor?.script) {\n      const scope = this.getScopeByOwnerId(executable.ownerId);\n      const scopeText = scope ? ` in ${scope}` : '';\n      throw `ConfigurationProcessor ${executable.apiName}${scopeText} not found`;\n    }\n\n    return this.executeProcessorScript(request, configurationProcessor, executable.inputData);\n  }\n\n  private executeProcessorScript(\n    request: FlowState,\n    configurationProcessor: ConfigurationProcessor,\n    inputData: unknown,\n  ): unknown {\n    let functionToExecute = this.executedFunctions[configurationProcessor.apiName];\n    if (!functionToExecute) {\n      functionToExecute = new Function(`${configurationProcessor.script}\\nreturn transform;`)();\n      this.executedFunctions[configurationProcessor.apiName] = functionToExecute;\n    }\n\n    return functionToExecute({\n      request,\n      inputData,\n    });\n  }\n\n  private generateRequestId(scope: UITemplateType, selectorName: string, inputData?: unknown): string {\n    const inputDataHash = UUID.hex(JSON.stringify(inputData) || '').slice(0, 8);\n    return `${scope}/${selectorName}/${inputDataHash}`;\n  }\n\n  private getDefaultExecutionRequestDTO(): FlowStateExecutionRequestDTO {\n    const request: FlowStateExecutionRequestDTO = {\n      actions: [],\n      selectors: {},\n    };\n\n    if (this.getFlowSafe().properties.standalone) {\n      return request;\n    }\n\n    const ownerId = this.getOwnerIdByScope(UITemplateType.FLOW_ENGINE);\n\n    request.actions?.push({\n      apiName: 'UPDATE_PRICE_LIST',\n      ownerId,\n      inputData: {},\n    });\n    request.actions?.push({\n      apiName: 'UPDATE_ASSET_IDS',\n      ownerId,\n      inputData: {},\n    });\n\n    request.actions?.push({\n      apiName: 'UPDATE_CONTEXT_PROPERTIES',\n      ownerId,\n      inputData: this.contextService.resolve().properties,\n    });\n\n    return request;\n  }\n}\n"]}

package/esm2020/core/services/index.mjs

@@ -1,6 +1,10 @@
 export * from './context.service';
+export * from './flow-info.service';
+export * from './flow-state.service';
+export * from './flow-state-configuration.service';
+export * from './integration.state';
 export * from './metric-calculation/metric-calculation.service';
 export * from './product-images.service';
 export * from './quote-draft.service';
 export * from './runtime-settings.service';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3Nkay9jb3JlL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxpREFBaUQsQ0FBQztBQUNoRSxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyw0QkFBNEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29udGV4dC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbWV0cmljLWNhbGN1bGF0aW9uL21ldHJpYy1jYWxjdWxhdGlvbi5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vcHJvZHVjdC1pbWFnZXMuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3F1b3RlLWRyYWZ0LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9ydW50aW1lLXNldHRpbmdzLnNlcnZpY2UnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3Nkay9jb3JlL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsb0NBQW9DLENBQUM7QUFDbkQsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGlEQUFpRCxDQUFDO0FBQ2hFLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLDRCQUE0QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jb250ZXh0LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9mbG93LWluZm8uc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2Zsb3ctc3RhdGUuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2Zsb3ctc3RhdGUtY29uZmlndXJhdGlvbi5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vaW50ZWdyYXRpb24uc3RhdGUnO1xuZXhwb3J0ICogZnJvbSAnLi9tZXRyaWMtY2FsY3VsYXRpb24vbWV0cmljLWNhbGN1bGF0aW9uLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9wcm9kdWN0LWltYWdlcy5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vcXVvdGUtZHJhZnQuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3J1bnRpbWUtc2V0dGluZ3Muc2VydmljZSc7XG4iXX0=

package/esm2020/core/services/integration.state.mjs

@@ -0,0 +1,36 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, filter, map, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class IntegrationState {
+    constructor() {
+        this.stateSubj$ = new BehaviorSubject({});
+        this.action$ = new Subject();
+    }
+    get state$() {
+        return this.stateSubj$.asObservable();
+    }
+    get state() {
+        return this.stateSubj$.getValue();
+    }
+    patchState(update) {
+        this.stateSubj$.next({ ...this.stateSubj$.getValue(), ...update });
+    }
+    dispatch(action) {
+        this.action$.next(action);
+    }
+    listen$(actionType) {
+        return this.action$.pipe(filter(action => action.type === actionType), map(action => action.payload));
+    }
+    listenAll$() {
+        return this.action$.asObservable();
+    }
+    clear() {
+        this.stateSubj$.next({});
+    }
+}
+IntegrationState.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: IntegrationState, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+IntegrationState.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: IntegrationState });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: IntegrationState, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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