@veloceapps/sdk 8.0.0-98 → 9.0.0-0

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

@@ -0,0 +1,512 @@
+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, buffer, catchError, combineLatest, debounceTime, filter, finalize, forkJoin, map, noop, of, share, shareReplay, Subject, switchMap, take, takeUntil, tap, throwError, } 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.EXECUTION_BUFFER_TIME = 100;
+        this.executedFunctions = {};
+        this.stateId$ = new BehaviorSubject(null);
+        this._hasStatefulUnsavedChanges = true;
+        this.processors = {};
+        this.subscriptions = {};
+        this.flowStore = {};
+        this.statefulExecutionInProgress$ = new BehaviorSubject(false);
+        this.statefulRequestStream$ = new Subject();
+        this.cleanup$ = new Subject();
+        this.statefulExecutionRequest$ = this.initBufferedRequest$();
+        /*
+          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(() => {
+            if (this.flowInfoService.isLegacy) {
+                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 : {})));
+            }
+        }), shareReplay(1));
+        this.charges$.subscribe();
+        this.pricePlans$ = this.flowInfoService.flow$.pipe(filter(isDefined), switchMap(() => {
+            if (this.flowInfoService.isLegacy) {
+                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 : {})));
+            }
+        }), shareReplay(1));
+        this.pricePlans$.subscribe();
+        this.activeMetrics$ = this.flowInfoService.flow$.pipe(filter(isDefined), switchMap(() => {
+            if (this.flowInfoService.isLegacy) {
+                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 : [])));
+            }
+        }), shareReplay(1));
+        this.activeMetrics$.subscribe();
+        this.isPriceListLocked$ = this.flowInfoService.flow$.pipe(filter(isDefined), switchMap(() => {
+            if (this.flowInfoService.isLegacy) {
+                return of(false);
+            }
+            else {
+                return this.subscribe$(UITemplateType.FLOW_ENGINE, 'IS_PRICE_LIST_LOCKED', null, {
+                    cold: true,
+                }).pipe(map(response => (response.success ? response.result : false)));
+            }
+        }), shareReplay(1));
+        this.isPriceListLocked$.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.flowStore = {};
+        this.cleanup$.next();
+    }
+    get hasUnsavedChanges() {
+        return this.getFlowSafe().properties.stateful
+            ? this._hasStatefulUnsavedChanges
+            : this.quoteDraftService.hasUnsavedChanges;
+    }
+    get stateId() {
+        return this.stateId$.value;
+    }
+    get isExecutionInProgress$() {
+        return this.statefulExecutionInProgress$.asObservable();
+    }
+    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);
+        let subscription = this.subscriptions[requestId];
+        if (!subscription) {
+            const request = this.execToRequest(scope, {
+                selectors: {
+                    [requestId]: {
+                        name: selectorName,
+                        inputData,
+                    },
+                },
+            });
+            subscription = {
+                request,
+                data$: new BehaviorSubject(this.NOT_INITIALIZED),
+            };
+            this.subscriptions[requestId] = subscription;
+            if (!options?.cold) {
+                this.executeRequest$(request).subscribe();
+            }
+        }
+        return subscription.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.quoteDraft;
+            if (quoteDraft) {
+                return this.quoteApiService.upsertQuote(quoteDraft).pipe(tap(({ configurationId }) => {
+                    this.contextService.update({ properties: { ConfigurationId: configurationId } });
+                }));
+            }
+        }
+        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.quoteDraft;
+            if (quoteDraft) {
+                return this.quoteApiService.submitQuote(quoteDraft).pipe(tap(({ configurationId }) => {
+                    this.contextService.update({ properties: { ConfigurationId: configurationId } });
+                }));
+            }
+        }
+        return of({ quoteId: '' });
+    }
+    getFlowStore() {
+        return this.flowStore;
+    }
+    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$.value !== selectorResult) {
+                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);
+        }));
+    }
+    initBufferedRequest$() {
+        return this.statefulRequestStream$.pipe(buffer(this.statefulRequestStream$.pipe(debounceTime(this.EXECUTION_BUFFER_TIME))), switchMap(requests => {
+            if (!this.stateId$.value) {
+                throw 'Stateful session is not initialized';
+            }
+            // merge buffered requests
+            const request = {
+                actions: requests.flatMap(({ actions }) => actions).filter(isDefined),
+                selectors: requests
+                    .map(({ selectors }) => selectors)
+                    .filter(isDefined)
+                    .reduce((acc, selectorsMap) => Object.assign(acc, selectorsMap), {}),
+            };
+            this.statefulExecutionInProgress$.next(true);
+            return this.flowStateApiService.execute(this.stateId$.value, request);
+        }), tap(({ stateId }) => this.stateId$.next(stateId)), share(), tap(() => this.statefulExecutionInProgress$.next(false)), catchError(e => {
+            this.statefulExecutionInProgress$.next(false);
+            return throwError(() => e);
+        }));
+    }
+    executeStateful$(request) {
+        return this.statefulExecutionInProgress$.pipe(filter(inProgress => !inProgress), take(1), switchMap(() => 
+        // make sure stream switches to statefulExecutionRequest$ before pushing an execution request
+        combineLatest([
+            this.statefulExecutionRequest$,
+            of(undefined).pipe(tap(() => this.statefulRequestStream$.next(request))),
+        ])), map(([response]) => response), take(1));
+    }
+    initStateless$() {
+        const { headerId } = this.contextService.resolve();
+        return this.quoteDraftService.init(headerId, this.flowInfoService.params ?? {}).pipe(tap(() => {
+            const assets = this.quoteDraftService.assetsState;
+            if (assets) {
+                this.flowStore = { ...this.flowStore, assets };
+            }
+        }), 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) {
+        const scope = this.getScopeByOwnerId(configurationProcessor.ownerId ?? '');
+        let functionToExecute = this.executedFunctions[scope + configurationProcessor.apiName];
+        if (!functionToExecute) {
+            const script = `${configurationProcessor.script}\nreturn transform;`;
+            const sourceMap = `\n//# sourceURL=${scope ? scope + '/' : ''}${configurationProcessor.apiName}.js`;
+            functionToExecute = new Function(script + sourceMap)();
+            this.executedFunctions[scope + configurationProcessor.apiName] = functionToExecute;
+        }
+        return functionToExecute({
+            request,
+            inputData,
+            flowStore: this.flowStore,
+        });
+    }
+    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 flowEngineTemplateId = this.getOwnerIdByScope(UITemplateType.FLOW_ENGINE);
+        request.actions?.push({
+            apiName: 'UPDATE_CONTEXT_PROPERTIES',
+            ownerId: flowEngineTemplateId,
+            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":"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","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  ConfigurationProcessorScriptFn,\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  buffer,\n  catchError,\n  combineLatest,\n  debounceTime,\n  filter,\n  finalize,\n  forkJoin,\n  map,\n  noop,\n  Observable,\n  of,\n  share,\n  shareReplay,\n  Subject,\n  switchMap,\n  take,\n  takeUntil,\n  tap,\n  throwError,\n} from 'rxjs';\nimport { FlowConfigurationService } from '../modules';\nimport { FlowCustomization, FLOW_CUSTOMIZATION } from '../types/flow-customization.types';\nimport { FlowStateSubscriptionOptions, FlowStore } 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  public isPriceListLocked$: Observable<boolean>;\n\n  private readonly NOT_INITIALIZED = Symbol();\n  private readonly EXECUTION_BUFFER_TIME = 100;\n\n  private executedFunctions: Dictionary<ConfigurationProcessorScriptFn> = {};\n  private stateId$ = new BehaviorSubject<string | null>(null);\n  private _hasStatefulUnsavedChanges = true;\n  private processors: ProcessorsMap = {};\n  private subscriptions: Record<string, Subscription> = {};\n  private flowStore: FlowStore = {};\n\n  private statefulExecutionInProgress$ = new BehaviorSubject(false);\n  private statefulRequestStream$ = new Subject<FlowStateExecutionRequestDTO>();\n  private statefulExecutionRequest$: Observable<FlowStateExecutionResult>;\n\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    this.statefulExecutionRequest$ = this.initBufferedRequest$();\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(() => {\n        if (this.flowInfoService.isLegacy) {\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      shareReplay(1),\n    );\n    this.charges$.subscribe();\n\n    this.pricePlans$ = this.flowInfoService.flow$.pipe(\n      filter(isDefined),\n      switchMap(() => {\n        if (this.flowInfoService.isLegacy) {\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      shareReplay(1),\n    );\n    this.pricePlans$.subscribe();\n\n    this.activeMetrics$ = this.flowInfoService.flow$.pipe(\n      filter(isDefined),\n      switchMap(() => {\n        if (this.flowInfoService.isLegacy) {\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      shareReplay(1),\n    );\n    this.activeMetrics$.subscribe();\n\n    this.isPriceListLocked$ = this.flowInfoService.flow$.pipe(\n      filter(isDefined),\n      switchMap(() => {\n        if (this.flowInfoService.isLegacy) {\n          return of(false);\n        } else {\n          return this.subscribe$<boolean>(UITemplateType.FLOW_ENGINE, 'IS_PRICE_LIST_LOCKED', null, {\n            cold: true,\n          }).pipe(map(response => (response.success ? response.result : false)));\n        }\n      }),\n      shareReplay(1),\n    );\n    this.isPriceListLocked$.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.flowStore = {};\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 get isExecutionInProgress$() {\n    return this.statefulExecutionInProgress$.asObservable();\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    let subscription = this.subscriptions[requestId];\n\n    if (!subscription) {\n      const request = this.execToRequest(scope, {\n        selectors: {\n          [requestId]: {\n            name: selectorName,\n            inputData,\n          },\n        },\n      });\n\n      subscription = {\n        request,\n        data$: new BehaviorSubject<unknown>(this.NOT_INITIALIZED),\n      };\n\n      this.subscriptions[requestId] = subscription;\n\n      if (!options?.cold) {\n        this.executeRequest$(request).subscribe();\n      }\n    }\n\n    return subscription.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.quoteDraft;\n      if (quoteDraft) {\n        return this.quoteApiService.upsertQuote(quoteDraft).pipe(\n          tap(({ configurationId }) => {\n            this.contextService.update({ properties: { ConfigurationId: configurationId } });\n          }),\n        );\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.quoteDraft;\n      if (quoteDraft) {\n        return this.quoteApiService.submitQuote(quoteDraft).pipe(\n          tap(({ configurationId }) => {\n            this.contextService.update({ properties: { ConfigurationId: configurationId } });\n          }),\n        );\n      }\n    }\n\n    return of({ quoteId: '' });\n  }\n\n  public getFlowStore(): Record<string, unknown> {\n    return this.flowStore;\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$ && subscription$.value !== selectorResult) {\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 initBufferedRequest$() {\n    return this.statefulRequestStream$.pipe(\n      buffer(this.statefulRequestStream$.pipe(debounceTime(this.EXECUTION_BUFFER_TIME))),\n      switchMap(requests => {\n        if (!this.stateId$.value) {\n          throw 'Stateful session is not initialized';\n        }\n\n        // merge buffered requests\n        const request: FlowStateExecutionRequestDTO = {\n          actions: requests.flatMap(({ actions }) => actions).filter(isDefined),\n          selectors: requests\n            .map(({ selectors }) => selectors)\n            .filter(isDefined)\n            .reduce((acc, selectorsMap) => Object.assign(acc, selectorsMap), {}),\n        };\n\n        this.statefulExecutionInProgress$.next(true);\n        return this.flowStateApiService.execute(this.stateId$.value, request);\n      }),\n      tap(({ stateId }) => this.stateId$.next(stateId)),\n      share(),\n      tap(() => this.statefulExecutionInProgress$.next(false)),\n      catchError(e => {\n        this.statefulExecutionInProgress$.next(false);\n        return throwError(() => e);\n      }),\n    );\n  }\n\n  private executeStateful$(request: FlowStateExecutionRequestDTO): Observable<FlowStateExecutionResult> {\n    return this.statefulExecutionInProgress$.pipe(\n      filter(inProgress => !inProgress),\n      take(1),\n      switchMap(() =>\n        // make sure stream switches to statefulExecutionRequest$ before pushing an execution request\n        combineLatest([\n          this.statefulExecutionRequest$,\n          of(undefined).pipe(tap(() => this.statefulRequestStream$.next(request))),\n        ]),\n      ),\n      map(([response]) => response),\n      take(1),\n    );\n  }\n\n  private initStateless$(): Observable<void> {\n    const { headerId } = this.contextService.resolve();\n    return this.quoteDraftService.init(headerId, this.flowInfoService.params ?? {}).pipe(\n      tap(() => {\n        const assets = this.quoteDraftService.assetsState;\n        if (assets) {\n          this.flowStore = { ...this.flowStore, assets };\n        }\n      }),\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    const scope = this.getScopeByOwnerId(configurationProcessor.ownerId ?? '');\n    let functionToExecute = this.executedFunctions[scope + configurationProcessor.apiName];\n\n    if (!functionToExecute) {\n      const script = `${configurationProcessor.script}\\nreturn transform;`;\n      const sourceMap = `\\n//# sourceURL=${scope ? scope + '/' : ''}${configurationProcessor.apiName}.js`;\n      functionToExecute = new Function(script + sourceMap)() as ConfigurationProcessorScriptFn;\n      this.executedFunctions[scope + configurationProcessor.apiName] = functionToExecute;\n    }\n\n    return functionToExecute({\n      request,\n      inputData,\n      flowStore: this.flowStore,\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 flowEngineTemplateId = this.getOwnerIdByScope(UITemplateType.FLOW_ENGINE);\n\n    request.actions?.push({\n      apiName: 'UPDATE_CONTEXT_PROPERTIES',\n      ownerId: flowEngineTemplateId,\n      inputData: this.contextService.resolve().properties,\n    });\n\n    return request;\n  }\n}\n"]}

package/esm2020/core/services/index.mjs

@@ -1,6 +1,9 @@
 export * from './context.service';
-export * from './metric-calculation/metric-calculation.service';
+export * from './flow-info.service';
+export * from './flow-state.service';
+export * from './flow-state-configuration.service';
+export * from './integration.state';
 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3Nkay9jb3JlL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsb0NBQW9DLENBQUM7QUFDbkQsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyw0QkFBNEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29udGV4dC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vZmxvdy1pbmZvLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9mbG93LXN0YXRlLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9mbG93LXN0YXRlLWNvbmZpZ3VyYXRpb24uc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2ludGVncmF0aW9uLnN0YXRlJztcbmV4cG9ydCAqIGZyb20gJy4vcHJvZHVjdC1pbWFnZXMuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3F1b3RlLWRyYWZ0LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9ydW50aW1lLXNldHRpbmdzLnNlcnZpY2UnO1xuIl19