@hmcts/ccd-case-ui-toolkit 7.0.35-angular-upgrade → 7.0.35

package/esm2020/lib/shared/components/event-start/resolvers/event-tasks-resolver.service.mjs

@@ -0,0 +1,29 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { SessionStorageService } from '../../../services/session/session-storage.service';
+import { WorkAllocationService } from '../../case-editor/services/work-allocation.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../case-editor/services/work-allocation.service";
+import * as i2 from "../../../services/session/session-storage.service";
+export class EventTasksResolverService {
+    constructor(service, sessionStorageService) {
+        this.service = service;
+        this.sessionStorageService = sessionStorageService;
+    }
+    resolve(route) {
+        const eventId = route.queryParamMap.get('eventId');
+        const caseId = route.queryParamMap.get('caseId');
+        const caseInfoStr = this.sessionStorageService.getItem('caseInfo');
+        const caseInfo = JSON.parse(caseInfoStr);
+        if (caseInfo) {
+            return this.service.getTasksByCaseIdAndEventId(eventId, caseId, caseInfo.caseType, caseInfo.jurisdiction)
+                .pipe(map((payload) => payload.tasks));
+        }
+    }
+}
+EventTasksResolverService.ɵfac = function EventTasksResolverService_Factory(t) { return new (t || EventTasksResolverService)(i0.ɵɵinject(i1.WorkAllocationService), i0.ɵɵinject(i2.SessionStorageService)); };
+EventTasksResolverService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: EventTasksResolverService, factory: EventTasksResolverService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(EventTasksResolverService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.WorkAllocationService }, { type: i2.SessionStorageService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/shared/components/event-start/services/event-start-state-machine.service.mjs

@@ -0,0 +1,168 @@
+import { Injectable } from '@angular/core';
+import { StateMachine } from '@edium/fsm';
+import { EventStartStates } from '../models';
+import * as i0 from "@angular/core";
+const EVENT_STATE_MACHINE = 'EVENT STATE MACHINE';
+export class EventStartStateMachineService {
+    initialiseStateMachine(context) {
+        return new StateMachine(EVENT_STATE_MACHINE, context);
+    }
+    createStates(stateMachine) {
+        // Initial state
+        this.stateCheckForMatchingTasks = stateMachine.createState(EventStartStates.CHECK_FOR_MATCHING_TASKS, false, this.entryActionForStateCheckForMatchingTasks);
+        // States based on number of tasks available
+        this.stateNoTask = stateMachine.createState(EventStartStates.NO_TASK, false, this.entryActionForStateNoTask);
+        this.stateOneOrMoreTasks = stateMachine.createState(EventStartStates.ONE_OR_MORE_TASKS, false, this.entryActionForStateOneOrMoreTasks);
+        // States based on number of tasks assigned to user
+        this.stateTaskUnassigned = stateMachine.createState(EventStartStates.TASK_UNASSIGNED, false, this.entryActionForStateTaskUnAssigned);
+        this.stateTaskAssignedToUser = stateMachine.createState(EventStartStates.TASK_ASSIGNED_TO_USER, false, this.entryActionForStateTaskAssignedToUser);
+        this.stateOneTaskAssignedToUser = stateMachine.createState(EventStartStates.ONE_TASK_ASSIGNED_TO_USER, false, this.entryActionForStateOneTaskAssignedToUser);
+        this.stateMultipleTasksAssignedToUser = stateMachine.createState(EventStartStates.MULTIPLE_TASKS_ASSIGNED_TO_USER, false, this.entryActionForStateMultipleTasksAssignedToUser);
+        // Create final state, the second param isComplete is set to true to make sure state machine finished running
+        this.stateFinal = stateMachine.createState(EventStartStates.FINAL, true, this.finalAction);
+    }
+    addTransitions() {
+        // Initial transition
+        this.addTransitionsForStateCheckForMatchingTasks();
+        // Transitions based on number of tasks available
+        this.addTransitionsForStateNoTask();
+        this.addTransitionsForStateOneOrMoreTasks();
+        // Transitions based on number of tasks assigned to user
+        this.addTransitionsForStateTaskUnassigned();
+        this.addTransitionsForStateTaskAssignedToUser();
+        this.addTransitionsForStateOneTaskAssignedToUser();
+        this.addTransitionsForStateMultipleTasksAssignedToUser();
+    }
+    startStateMachine(stateMachine) {
+        stateMachine.start(this.stateCheckForMatchingTasks);
+    }
+    /**
+     * Initial entry action for state check for matching tasks, decided based on the number of tasks
+     */
+    entryActionForStateCheckForMatchingTasks(state, context) {
+        const taskCount = context && context.tasks ? context.tasks.length : 0;
+        if (taskCount === 0) {
+            // Trigger state no task
+            state.trigger(EventStartStates.NO_TASK);
+        }
+        else {
+            // Trigger state one or more tasks
+            state.trigger(EventStartStates.ONE_OR_MORE_TASKS);
+        }
+    }
+    entryActionForStateNoTask(state, context) {
+        // Trigger final state to complete processing of state machine
+        state.trigger(EventStartStates.FINAL);
+        // Navigate to no tasks available error page
+        context.router.navigate([`/cases/case-details/${context.caseId}/no-tasks-available`], { relativeTo: context.route });
+    }
+    entryActionForStateOneOrMoreTasks(state, context) {
+        state.trigger(EventStartStates.TASK_ASSIGNED_TO_USER);
+    }
+    entryActionForStateMultipleTasks(state, context) {
+        state.trigger(EventStartStates.MULTIPLE_TASKS_ASSIGNED_TO_USER);
+    }
+    entryActionForStateTaskAssignedToUser(state, context) {
+        // Get number of tasks assigned to user
+        const userInfoStr = context.sessionStorageService.getItem('userDetails');
+        const userInfo = JSON.parse(userInfoStr);
+        const tasksAssignedToUser = context.tasks.filter(x => x.task_state !== 'unassigned' && x.assignee === userInfo.id || x.assignee === userInfo.uid);
+        // Check if user initiated the event from task tab
+        const isEventInitiatedFromTaskTab = context.taskId !== undefined && tasksAssignedToUser.findIndex(x => x.id === context.taskId) > -1;
+        if (isEventInitiatedFromTaskTab) {
+            // User initiated event from task tab
+            state.trigger(EventStartStates.ONE_TASK_ASSIGNED_TO_USER);
+        }
+        else {
+            // User initiated event from dropdown
+            switch (tasksAssignedToUser.length) {
+                case 0:
+                    // No tasks assigned to user, trigger state task unassigned
+                    state.trigger(EventStartStates.TASK_UNASSIGNED);
+                    break;
+                case 1:
+                    // One task assigned to user
+                    state.trigger(EventStartStates.ONE_TASK_ASSIGNED_TO_USER);
+                    break;
+                default:
+                    // Multiple tasks assigned to user, trigger state multiple tasks assigned to user
+                    state.trigger(EventStartStates.MULTIPLE_TASKS_ASSIGNED_TO_USER);
+                    break;
+            }
+        }
+    }
+    entryActionForStateTaskUnAssigned(state, context) {
+        let navigationURL = '';
+        let theQueryParams = {};
+        if (context.tasks[0].assignee) {
+            // Task is assigned to some other user, navigate to task assigned error page
+            navigationURL = `/cases/case-details/${context.caseId}/task-assigned`;
+            theQueryParams = context.tasks[0];
+        }
+        else {
+            // Task is unassigned, navigate to task unassigned error page
+            navigationURL = `/cases/case-details/${context.caseId}/task-unassigned`;
+        }
+        // Trigger final state to complete processing of state machine
+        state.trigger(EventStartStates.FINAL);
+        // Navigate
+        context.router.navigate([`${navigationURL}`], { queryParams: theQueryParams, relativeTo: context.route });
+    }
+    entryActionForStateOneTaskAssignedToUser(state, context) {
+        // Trigger final state to complete processing of state machine
+        state.trigger(EventStartStates.FINAL);
+        // Get task assigned to user
+        let task = context.tasks.find(x => x.id === context.taskId);
+        if (!task) {
+            task = context.tasks[0];
+        }
+        // Store task to session
+        context.sessionStorageService.setItem('taskToComplete', JSON.stringify(task));
+        // Allow user to perform the event
+        context.router.navigate([`/cases/case-details/${context.caseId}/trigger/${context.eventId}`], { queryParams: { isComplete: true }, relativeTo: context.route });
+    }
+    entryActionForStateMultipleTasksAssignedToUser(state, context) {
+        // Trigger final state to complete processing of state machine
+        state.trigger(EventStartStates.FINAL);
+        // Navigate to multiple tasks exist error page
+        context.router.navigate([`/cases/case-details/${context.caseId}/multiple-tasks-exist`], { relativeTo: context.route });
+    }
+    finalAction(state) {
+        // Final actions can be performed here, the state machine finished running
+        // console.log('FINAL', state);
+        return;
+    }
+    addTransitionsForStateCheckForMatchingTasks() {
+        // No tasks
+        this.stateCheckForMatchingTasks.addTransition(EventStartStates.NO_TASK, this.stateNoTask);
+        // One task
+        this.stateCheckForMatchingTasks.addTransition(EventStartStates.ONE_OR_MORE_TASKS, this.stateOneOrMoreTasks);
+    }
+    addTransitionsForStateNoTask() {
+        this.stateNoTask.addTransition(EventStartStates.FINAL, this.stateFinal);
+    }
+    addTransitionsForStateOneOrMoreTasks() {
+        this.stateOneOrMoreTasks.addTransition(EventStartStates.TASK_ASSIGNED_TO_USER, this.stateTaskAssignedToUser);
+    }
+    addTransitionsForStateTaskUnassigned() {
+        this.stateTaskUnassigned.addTransition(EventStartStates.FINAL, this.stateFinal);
+    }
+    addTransitionsForStateTaskAssignedToUser() {
+        this.stateTaskAssignedToUser.addTransition(EventStartStates.ONE_TASK_ASSIGNED_TO_USER, this.stateOneTaskAssignedToUser);
+        this.stateTaskAssignedToUser.addTransition(EventStartStates.TASK_UNASSIGNED, this.stateTaskUnassigned);
+        this.stateTaskAssignedToUser.addTransition(EventStartStates.MULTIPLE_TASKS_ASSIGNED_TO_USER, this.stateMultipleTasksAssignedToUser);
+        this.stateTaskAssignedToUser.addTransition(EventStartStates.FINAL, this.stateFinal);
+    }
+    addTransitionsForStateOneTaskAssignedToUser() {
+        this.stateOneTaskAssignedToUser.addTransition(EventStartStates.FINAL, this.stateFinal);
+    }
+    addTransitionsForStateMultipleTasksAssignedToUser() {
+        this.stateMultipleTasksAssignedToUser.addTransition(EventStartStates.FINAL, this.stateFinal);
+    }
+}
+EventStartStateMachineService.ɵfac = function EventStartStateMachineService_Factory(t) { return new (t || EventStartStateMachineService)(); };
+EventStartStateMachineService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: EventStartStateMachineService, factory: EventStartStateMachineService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(EventStartStateMachineService, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event-start-state-machine.service.js","sourceRoot":"","sources":["../../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/components/event-start/services/event-start-state-machine.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Params } from '@angular/router';\nimport { State, StateMachine } from '@edium/fsm';\nimport { EventStartStateMachineContext, EventStartStates } from '../models';\n\nconst EVENT_STATE_MACHINE = 'EVENT STATE MACHINE';\n\n@Injectable()\nexport class EventStartStateMachineService {\n  public stateCheckForMatchingTasks: State;\n  public stateNoTask: State;\n  public stateOneTask: State;\n  public stateOneOrMoreTasks: State;\n  public stateTaskAssignedToUser: State;\n  public stateOneTaskAssignedToUser: State;\n  public stateMultipleTasksAssignedToUser: State;\n  public stateTaskUnassigned: State;\n  public stateFinal: State;\n\n  public initialiseStateMachine(context: EventStartStateMachineContext): StateMachine {\n    return new StateMachine(EVENT_STATE_MACHINE, context);\n  }\n\n  public createStates(stateMachine: StateMachine): void {\n    // Initial state\n    this.stateCheckForMatchingTasks = stateMachine.createState(\n      EventStartStates.CHECK_FOR_MATCHING_TASKS,\n      false,\n      this.entryActionForStateCheckForMatchingTasks\n    );\n\n    // States based on number of tasks available\n    this.stateNoTask = stateMachine.createState(\n      EventStartStates.NO_TASK,\n      false,\n      this.entryActionForStateNoTask\n    );\n    this.stateOneOrMoreTasks = stateMachine.createState(\n      EventStartStates.ONE_OR_MORE_TASKS,\n      false,\n      this.entryActionForStateOneOrMoreTasks\n    );\n\n    // States based on number of tasks assigned to user\n    this.stateTaskUnassigned = stateMachine.createState(\n      EventStartStates.TASK_UNASSIGNED,\n      false,\n      this.entryActionForStateTaskUnAssigned\n    );\n    this.stateTaskAssignedToUser = stateMachine.createState(\n      EventStartStates.TASK_ASSIGNED_TO_USER,\n      false,\n      this.entryActionForStateTaskAssignedToUser\n    );\n    this.stateOneTaskAssignedToUser = stateMachine.createState(\n      EventStartStates.ONE_TASK_ASSIGNED_TO_USER,\n      false,\n      this.entryActionForStateOneTaskAssignedToUser\n    );\n    this.stateMultipleTasksAssignedToUser = stateMachine.createState(\n      EventStartStates.MULTIPLE_TASKS_ASSIGNED_TO_USER,\n      false,\n      this.entryActionForStateMultipleTasksAssignedToUser\n    );\n\n    // Create final state, the second param isComplete is set to true to make sure state machine finished running\n    this.stateFinal = stateMachine.createState(\n      EventStartStates.FINAL,\n      true,\n      this.finalAction\n    );\n  }\n\n  public addTransitions(): void {\n    // Initial transition\n    this.addTransitionsForStateCheckForMatchingTasks();\n\n    // Transitions based on number of tasks available\n    this.addTransitionsForStateNoTask();\n    this.addTransitionsForStateOneOrMoreTasks();\n\n    // Transitions based on number of tasks assigned to user\n    this.addTransitionsForStateTaskUnassigned();\n    this.addTransitionsForStateTaskAssignedToUser();\n    this.addTransitionsForStateOneTaskAssignedToUser();\n    this.addTransitionsForStateMultipleTasksAssignedToUser();\n  }\n\n  public startStateMachine(stateMachine: StateMachine): void {\n    stateMachine.start(this.stateCheckForMatchingTasks);\n  }\n\n  /**\n   * Initial entry action for state check for matching tasks, decided based on the number of tasks\n   */\n  public entryActionForStateCheckForMatchingTasks(state: State, context: EventStartStateMachineContext): void {\n    const taskCount = context && context.tasks ? context.tasks.length : 0;\n\n    if (taskCount === 0) {\n      // Trigger state no task\n      state.trigger(EventStartStates.NO_TASK);\n    } else {\n      // Trigger state one or more tasks\n      state.trigger(EventStartStates.ONE_OR_MORE_TASKS);\n    }\n  }\n\n  public entryActionForStateNoTask(state: State, context: EventStartStateMachineContext): void {\n    // Trigger final state to complete processing of state machine\n    state.trigger(EventStartStates.FINAL);\n    // Navigate to no tasks available error page\n    context.router.navigate([`/cases/case-details/${context.caseId}/no-tasks-available`], { relativeTo: context.route });\n  }\n\n  public entryActionForStateOneOrMoreTasks(state: State, context: EventStartStateMachineContext): void {\n    state.trigger(EventStartStates.TASK_ASSIGNED_TO_USER);\n  }\n\n  public entryActionForStateMultipleTasks(state: State, context: EventStartStateMachineContext): void {\n    state.trigger(EventStartStates.MULTIPLE_TASKS_ASSIGNED_TO_USER);\n  }\n\n  public entryActionForStateTaskAssignedToUser(state: State, context: EventStartStateMachineContext): void {\n    // Get number of tasks assigned to user\n    const userInfoStr = context.sessionStorageService.getItem('userDetails');\n    const userInfo = JSON.parse(userInfoStr);\n    const tasksAssignedToUser = context.tasks.filter(x =>\n        x.task_state !== 'unassigned' && x.assignee === userInfo.id || x.assignee === userInfo.uid\n      );\n\n    // Check if user initiated the event from task tab\n    const isEventInitiatedFromTaskTab = context.taskId !== undefined && tasksAssignedToUser.findIndex(x => x.id === context.taskId) > -1;\n\n    if (isEventInitiatedFromTaskTab) {\n      // User initiated event from task tab\n      state.trigger(EventStartStates.ONE_TASK_ASSIGNED_TO_USER);\n    } else {\n      // User initiated event from dropdown\n      switch (tasksAssignedToUser.length) {\n        case 0:\n          // No tasks assigned to user, trigger state task unassigned\n          state.trigger(EventStartStates.TASK_UNASSIGNED);\n          break;\n        case 1:\n          // One task assigned to user\n          state.trigger(EventStartStates.ONE_TASK_ASSIGNED_TO_USER);\n          break;\n        default:\n          // Multiple tasks assigned to user, trigger state multiple tasks assigned to user\n          state.trigger(EventStartStates.MULTIPLE_TASKS_ASSIGNED_TO_USER);\n          break;\n      }\n    }\n  }\n\n  public entryActionForStateTaskUnAssigned(state: State, context: EventStartStateMachineContext): void {\n    let navigationURL = '';\n    let theQueryParams: Params = {};\n\n    if (context.tasks[0].assignee) {\n      // Task is assigned to some other user, navigate to task assigned error page\n      navigationURL = `/cases/case-details/${context.caseId}/task-assigned`;\n      theQueryParams = context.tasks[0];\n    } else {\n      // Task is unassigned, navigate to task unassigned error page\n      navigationURL = `/cases/case-details/${context.caseId}/task-unassigned`;\n    }\n\n    // Trigger final state to complete processing of state machine\n    state.trigger(EventStartStates.FINAL);\n    // Navigate\n    context.router.navigate([`${navigationURL}`], { queryParams: theQueryParams, relativeTo: context.route });\n  }\n\n  public entryActionForStateOneTaskAssignedToUser(state: State, context: EventStartStateMachineContext): void {\n    // Trigger final state to complete processing of state machine\n    state.trigger(EventStartStates.FINAL);\n\n    // Get task assigned to user\n    let task = context.tasks.find(x => x.id === context.taskId);\n    if (!task) {\n      task = context.tasks[0];\n    }\n\n    // Store task to session\n    context.sessionStorageService.setItem('taskToComplete', JSON.stringify(task));\n    // Allow user to perform the event\n    context.router.navigate([`/cases/case-details/${context.caseId}/trigger/${context.eventId}`],\n      { queryParams: { isComplete: true }, relativeTo: context.route });\n  }\n\n  public entryActionForStateMultipleTasksAssignedToUser(state: State, context: EventStartStateMachineContext): void {\n    // Trigger final state to complete processing of state machine\n    state.trigger(EventStartStates.FINAL);\n    // Navigate to multiple tasks exist error page\n    context.router.navigate([`/cases/case-details/${context.caseId}/multiple-tasks-exist`], { relativeTo: context.route });\n  }\n\n  public finalAction(state: State): void {\n    // Final actions can be performed here, the state machine finished running\n    // console.log('FINAL', state);\n    return;\n  }\n\n  public addTransitionsForStateCheckForMatchingTasks(): void {\n    // No tasks\n    this.stateCheckForMatchingTasks.addTransition(\n      EventStartStates.NO_TASK,\n      this.stateNoTask\n    );\n    // One task\n    this.stateCheckForMatchingTasks.addTransition(\n      EventStartStates.ONE_OR_MORE_TASKS,\n      this.stateOneOrMoreTasks\n    );\n  }\n\n  public addTransitionsForStateNoTask(): void {\n    this.stateNoTask.addTransition(\n      EventStartStates.FINAL,\n      this.stateFinal\n    );\n  }\n\n  public addTransitionsForStateOneOrMoreTasks(): void {\n    this.stateOneOrMoreTasks.addTransition(\n      EventStartStates.TASK_ASSIGNED_TO_USER,\n      this.stateTaskAssignedToUser\n    );\n  }\n\n  public addTransitionsForStateTaskUnassigned(): void {\n    this.stateTaskUnassigned.addTransition(\n      EventStartStates.FINAL,\n      this.stateFinal\n    );\n  }\n\n  public addTransitionsForStateTaskAssignedToUser(): void {\n    this.stateTaskAssignedToUser.addTransition(\n      EventStartStates.ONE_TASK_ASSIGNED_TO_USER,\n      this.stateOneTaskAssignedToUser\n    );\n    this.stateTaskAssignedToUser.addTransition(\n      EventStartStates.TASK_UNASSIGNED,\n      this.stateTaskUnassigned\n    );\n    this.stateTaskAssignedToUser.addTransition(\n      EventStartStates.MULTIPLE_TASKS_ASSIGNED_TO_USER,\n      this.stateMultipleTasksAssignedToUser\n    );\n    this.stateTaskAssignedToUser.addTransition(\n      EventStartStates.FINAL,\n      this.stateFinal\n    );\n  }\n\n  public addTransitionsForStateOneTaskAssignedToUser(): void {\n    this.stateOneTaskAssignedToUser.addTransition(\n      EventStartStates.FINAL,\n      this.stateFinal\n    );\n  }\n\n  public addTransitionsForStateMultipleTasksAssignedToUser(): void {\n    this.stateMultipleTasksAssignedToUser.addTransition(\n      EventStartStates.FINAL,\n      this.stateFinal\n    );\n  }\n}\n"]}

package/esm2020/lib/shared/components/event-trigger/event-trigger.component.mjs

@@ -0,0 +1,111 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { FormBuilder, Validators } from '@angular/forms';
+import { OrderService } from '../../services/order/order.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "../../services/order/order.service";
+import * as i3 from "@angular/common";
+import * as i4 from "rpx-xui-translation";
+function EventTriggerComponent_form_0_option_6_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "option", 8);
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "rpxTranslate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(2, 1, "Select action"));
+} }
+function EventTriggerComponent_form_0_option_7_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "option", 9);
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "rpxTranslate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const trigger_r3 = ctx.$implicit;
+    i0.ɵɵproperty("ngValue", trigger_r3)("title", trigger_r3.description);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(2, 3, trigger_r3.name));
+} }
+const _c0 = function (a0) { return { "EventTrigger-empty": a0 }; };
+function EventTriggerComponent_form_0_Template(rf, ctx) { if (rf & 1) {
+    const _r5 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "form", 1);
+    i0.ɵɵlistener("ngSubmit", function EventTriggerComponent_form_0_Template_form_ngSubmit_0_listener() { i0.ɵɵrestoreView(_r5); const ctx_r4 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r4.triggerSubmit()); });
+    i0.ɵɵelementStart(1, "div", 2)(2, "label", 3);
+    i0.ɵɵtext(3);
+    i0.ɵɵpipe(4, "rpxTranslate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(5, "select", 4);
+    i0.ɵɵlistener("change", function EventTriggerComponent_form_0_Template_select_change_5_listener() { i0.ɵɵrestoreView(_r5); const ctx_r6 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r6.triggerChange()); });
+    i0.ɵɵtemplate(6, EventTriggerComponent_form_0_option_6_Template, 3, 3, "option", 5);
+    i0.ɵɵtemplate(7, EventTriggerComponent_form_0_option_7_Template, 3, 5, "option", 6);
+    i0.ɵɵelementEnd()();
+    i0.ɵɵelementStart(8, "button", 7);
+    i0.ɵɵtext(9);
+    i0.ɵɵpipe(10, "rpxTranslate");
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("formGroup", ctx_r0.triggerForm);
+    i0.ɵɵadvance(3);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(4, 7, "Next step"));
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("ngClass", i0.ɵɵpureFunction1(11, _c0, !ctx_r0.triggerForm.value["trigger"]));
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", 1 !== ctx_r0.triggers.length);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngForOf", ctx_r0.triggers);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("disabled", ctx_r0.isButtonDisabled());
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(10, 9, ctx_r0.triggerText));
+} }
+export class EventTriggerComponent {
+    constructor(fb, orderService) {
+        this.fb = fb;
+        this.orderService = orderService;
+        this.onTriggerSubmit = new EventEmitter();
+        this.onTriggerChange = new EventEmitter();
+    }
+    ngOnChanges(changes) {
+        if (changes.triggers && changes.triggers.currentValue) {
+            this.triggers = this.orderService.sort(this.triggers);
+            this.triggerForm = this.fb.group({
+                trigger: [this.getDefault(), Validators.required]
+            });
+        }
+    }
+    isButtonDisabled() {
+        return !this.triggerForm.valid || this.isDisabled;
+    }
+    triggerSubmit() {
+        this.onTriggerSubmit.emit(this.triggerForm.value['trigger']);
+    }
+    triggerChange() {
+        this.onTriggerChange.emit(null);
+    }
+    getDefault() {
+        return this.triggers.length === 1 ? this.triggers[0] : '';
+    }
+}
+EventTriggerComponent.ɵfac = function EventTriggerComponent_Factory(t) { return new (t || EventTriggerComponent)(i0.ɵɵdirectiveInject(i1.FormBuilder), i0.ɵɵdirectiveInject(i2.OrderService)); };
+EventTriggerComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: EventTriggerComponent, selectors: [["ccd-event-trigger"]], inputs: { triggers: "triggers", triggerText: "triggerText", isDisabled: "isDisabled" }, outputs: { onTriggerSubmit: "onTriggerSubmit", onTriggerChange: "onTriggerChange" }, features: [i0.ɵɵNgOnChangesFeature], decls: 1, vars: 1, consts: [["class", "event-trigger", 3, "formGroup", "ngSubmit", 4, "ngIf"], [1, "event-trigger", 3, "formGroup", "ngSubmit"], [1, "form-group", 2, "width", "350px !important"], ["for", "next-step", 1, "form-label"], ["id", "next-step", "formControlName", "trigger", 1, "form-control", "ccd-dropdown", 3, "ngClass", "change"], ["value", "", "data-default", "", 4, "ngIf"], [3, "ngValue", "title", 4, "ngFor", "ngForOf"], ["type", "submit", 1, "button", 3, "disabled"], ["value", "", "data-default", ""], [3, "ngValue", "title"]], template: function EventTriggerComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵtemplate(0, EventTriggerComponent_form_0_Template, 11, 13, "form", 0);
+    } if (rf & 2) {
+        i0.ɵɵproperty("ngIf", ctx.triggers && ctx.triggers.length);
+    } }, dependencies: [i3.NgClass, i3.NgForOf, i3.NgIf, i1.ɵNgNoValidate, i1.NgSelectOption, i1.ɵNgSelectMultipleOption, i1.SelectControlValueAccessor, i1.NgControlStatus, i1.NgControlStatusGroup, i1.FormGroupDirective, i1.FormControlName, i4.RpxTranslatePipe], styles: [".event-trigger[_ngcontent-%COMP%]{width:auto;margin-top:40px;margin-bottom:20px}.event-trigger[_ngcontent-%COMP%]   .form-group[_ngcontent-%COMP%]{margin-top:3px;margin-right:10px;margin-bottom:0;float:left;text-align:right;width:325px}.event-trigger[_ngcontent-%COMP%]   .form-group[_ngcontent-%COMP%]   .form-label[_ngcontent-%COMP%]{float:left;margin-top:5px}.event-trigger[_ngcontent-%COMP%]   select[_ngcontent-%COMP%]{width:250px}.event-trigger[_ngcontent-%COMP%]   select.EventTrigger-empty[_ngcontent-%COMP%], .event-trigger[_ngcontent-%COMP%]   select[_ngcontent-%COMP%]   [data-default][_ngcontent-%COMP%]{color:#6f777b}"] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(EventTriggerComponent, [{
+        type: Component,
+        args: [{ selector: 'ccd-event-trigger', template: "<form *ngIf=\"triggers && triggers.length\" class=\"event-trigger\" (ngSubmit)=\"triggerSubmit()\" [formGroup]=\"triggerForm\">\n  <div class=\"form-group\" style=\"width: 350px !important;\">\n    <label class=\"form-label\" for=\"next-step\">{{'Next step' | rpxTranslate}}</label>\n    <select class=\"form-control ccd-dropdown\" id=\"next-step\" (change)=\"triggerChange()\" formControlName=\"trigger\" [ngClass]=\"{\n          'EventTrigger-empty': !triggerForm.value['trigger']\n        }\">\n      <option *ngIf=\"1 !== triggers.length\" value=\"\" data-default>{{'Select action' | rpxTranslate}}</option>\n      <option *ngFor=\"let trigger of triggers\" [ngValue]=\"trigger\" [title]=\"trigger.description\">{{trigger.name | rpxTranslate}}</option>\n    </select>\n  </div>\n  <button [disabled]=\"isButtonDisabled()\" type=\"submit\" class=\"button\">{{triggerText | rpxTranslate}}</button>\n</form>\n", styles: [".event-trigger{width:auto;margin-top:40px;margin-bottom:20px}.event-trigger .form-group{margin-top:3px;margin-right:10px;margin-bottom:0;float:left;text-align:right;width:325px}.event-trigger .form-group .form-label{float:left;margin-top:5px}.event-trigger select{width:250px}.event-trigger select.EventTrigger-empty,.event-trigger select [data-default]{color:#6f777b}\n"] }]
+    }], function () { return [{ type: i1.FormBuilder }, { type: i2.OrderService }]; }, { triggers: [{
+            type: Input
+        }], triggerText: [{
+            type: Input
+        }], isDisabled: [{
+            type: Input
+        }], onTriggerSubmit: [{
+            type: Output
+        }], onTriggerChange: [{
+            type: Output
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/shared/components/event-trigger/event-trigger.module.mjs

@@ -0,0 +1,37 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ReactiveFormsModule } from '@angular/forms';
+import { RpxTranslationModule } from 'rpx-xui-translation';
+import { ActivityModule } from '../activity';
+import { EventTriggerComponent } from './event-trigger.component';
+import * as i0 from "@angular/core";
+import * as i1 from "rpx-xui-translation";
+export class EventTriggerModule {
+}
+EventTriggerModule.ɵfac = function EventTriggerModule_Factory(t) { return new (t || EventTriggerModule)(); };
+EventTriggerModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: EventTriggerModule });
+EventTriggerModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [CommonModule,
+        ReactiveFormsModule,
+        ActivityModule,
+        RpxTranslationModule.forChild()] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(EventTriggerModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    CommonModule,
+                    ReactiveFormsModule,
+                    ActivityModule,
+                    RpxTranslationModule.forChild()
+                ],
+                declarations: [
+                    EventTriggerComponent
+                ],
+                exports: [
+                    EventTriggerComponent
+                ]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(EventTriggerModule, { declarations: [EventTriggerComponent], imports: [CommonModule,
+        ReactiveFormsModule,
+        ActivityModule, i1.RpxTranslationModule], exports: [EventTriggerComponent] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnQtdHJpZ2dlci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jY2QtY2FzZS11aS10b29sa2l0L3NyYy9saWIvc2hhcmVkL2NvbXBvbmVudHMvZXZlbnQtdHJpZ2dlci9ldmVudC10cmlnZ2VyLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUNyRCxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUMzRCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQzdDLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDJCQUEyQixDQUFDOzs7QUFnQmxFLE1BQU0sT0FBTyxrQkFBa0I7O29GQUFsQixrQkFBa0I7b0VBQWxCLGtCQUFrQjt3RUFaM0IsWUFBWTtRQUNaLG1CQUFtQjtRQUNuQixjQUFjO1FBQ2Qsb0JBQW9CLENBQUMsUUFBUSxFQUFFO3VGQVN0QixrQkFBa0I7Y0FkOUIsUUFBUTtlQUFDO2dCQUNSLE9BQU8sRUFBRTtvQkFDUCxZQUFZO29CQUNaLG1CQUFtQjtvQkFDbkIsY0FBYztvQkFDZCxvQkFBb0IsQ0FBQyxRQUFRLEVBQUU7aUJBQ2hDO2dCQUNELFlBQVksRUFBRTtvQkFDWixxQkFBcUI7aUJBQ3RCO2dCQUNELE9BQU8sRUFBRTtvQkFDUCxxQkFBcUI7aUJBQ3RCO2FBQ0Y7O3dGQUNZLGtCQUFrQixtQkFOM0IscUJBQXFCLGFBTnJCLFlBQVk7UUFDWixtQkFBbUI7UUFDbkIsY0FBYyxzQ0FPZCxxQkFBcUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFJlYWN0aXZlRm9ybXNNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5pbXBvcnQgeyBScHhUcmFuc2xhdGlvbk1vZHVsZSB9IGZyb20gJ3JweC14dWktdHJhbnNsYXRpb24nO1xuaW1wb3J0IHsgQWN0aXZpdHlNb2R1bGUgfSBmcm9tICcuLi9hY3Rpdml0eSc7XG5pbXBvcnQgeyBFdmVudFRyaWdnZXJDb21wb25lbnQgfSBmcm9tICcuL2V2ZW50LXRyaWdnZXIuY29tcG9uZW50JztcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW1xuICAgIENvbW1vbk1vZHVsZSxcbiAgICBSZWFjdGl2ZUZvcm1zTW9kdWxlLFxuICAgIEFjdGl2aXR5TW9kdWxlLFxuICAgIFJweFRyYW5zbGF0aW9uTW9kdWxlLmZvckNoaWxkKClcbiAgXSxcbiAgZGVjbGFyYXRpb25zOiBbXG4gICAgRXZlbnRUcmlnZ2VyQ29tcG9uZW50XG4gIF0sXG4gIGV4cG9ydHM6IFtcbiAgICBFdmVudFRyaWdnZXJDb21wb25lbnRcbiAgXVxufSlcbmV4cG9ydCBjbGFzcyBFdmVudFRyaWdnZXJNb2R1bGUge31cbiJdfQ==

package/esm2020/lib/shared/components/loading-spinner/loading-spinner.component.mjs

@@ -0,0 +1,27 @@
+import { Component, Input, ViewEncapsulation } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "rpx-xui-translation";
+export class LoadingSpinnerComponent {
+    constructor() {
+        this.loadingText = 'Loading';
+    }
+}
+LoadingSpinnerComponent.ɵfac = function LoadingSpinnerComponent_Factory(t) { return new (t || LoadingSpinnerComponent)(); };
+LoadingSpinnerComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LoadingSpinnerComponent, selectors: [["ccd-loading-spinner"]], inputs: { loadingText: "loadingText" }, decls: 6, vars: 3, consts: [[1, "spinner-container"], [1, "spinner-inner-container"], [1, "spinner", 2, "margin", "auto"]], template: function LoadingSpinnerComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "div", 0)(1, "div", 1)(2, "p");
+        i0.ɵɵtext(3);
+        i0.ɵɵpipe(4, "rpxTranslate");
+        i0.ɵɵelementEnd();
+        i0.ɵɵelement(5, "div", 2);
+        i0.ɵɵelementEnd()();
+    } if (rf & 2) {
+        i0.ɵɵadvance(3);
+        i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(4, 1, ctx.loadingText));
+    } }, dependencies: [i1.RpxTranslatePipe], styles: [".spinner-container{position:fixed;top:0;left:0;height:100%;width:100%;display:flex;justify-content:center;align-items:center;background:rgba(255,255,255,.5);z-index:99}.spinner-container .spinner-inner-container p{text-align:center}.spinner-container .spinner-inner-container .spinner{border:10px solid #dddddd;border-top:10px solid #000000;border-radius:50%;width:40px;height:40px;animation:spin 1s linear infinite}@keyframes spin{0%{transform:rotate(0)}to{transform:rotate(360deg)}}\n"], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LoadingSpinnerComponent, [{
+        type: Component,
+        args: [{ selector: 'ccd-loading-spinner', encapsulation: ViewEncapsulation.None, template: "<div class=\"spinner-container\">\n    <div class=\"spinner-inner-container\">\n        <p>{{loadingText | rpxTranslate}}</p>\n        <div class=\"spinner\" style=\"margin: auto;\"></div>\n    </div>\n</div>\n", styles: [".spinner-container{position:fixed;top:0;left:0;height:100%;width:100%;display:flex;justify-content:center;align-items:center;background:rgba(255,255,255,.5);z-index:99}.spinner-container .spinner-inner-container p{text-align:center}.spinner-container .spinner-inner-container .spinner{border:10px solid #dddddd;border-top:10px solid #000000;border-radius:50%;width:40px;height:40px;animation:spin 1s linear infinite}@keyframes spin{0%{transform:rotate(0)}to{transform:rotate(360deg)}}\n"] }]
+    }], null, { loadingText: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZGluZy1zcGlubmVyLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NjZC1jYXNlLXVpLXRvb2xraXQvc3JjL2xpYi9zaGFyZWQvY29tcG9uZW50cy9sb2FkaW5nLXNwaW5uZXIvbG9hZGluZy1zcGlubmVyLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NjZC1jYXNlLXVpLXRvb2xraXQvc3JjL2xpYi9zaGFyZWQvY29tcG9uZW50cy9sb2FkaW5nLXNwaW5uZXIvbG9hZGluZy1zcGlubmVyLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sZUFBZSxDQUFDOzs7QUFTcEUsTUFBTSxPQUFPLHVCQUF1QjtJQVBwQztRQVFrQixnQkFBVyxHQUFHLFNBQVMsQ0FBQztLQUN6Qzs7OEZBRlksdUJBQXVCOzBFQUF2Qix1QkFBdUI7UUNUcEMsOEJBQStCLGFBQUEsUUFBQTtRQUVwQixZQUE4Qjs7UUFBQSxpQkFBSTtRQUNyQyx5QkFBaUQ7UUFDckQsaUJBQU0sRUFBQTs7UUFGQyxlQUE4QjtRQUE5QiwyREFBOEI7O3VGRE81Qix1QkFBdUI7Y0FQbkMsU0FBUzsyQkFDRSxxQkFBcUIsaUJBR2hCLGlCQUFpQixDQUFDLElBQUk7Z0JBSXJCLFdBQVc7a0JBQTFCLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIElucHV0LCBWaWV3RW5jYXBzdWxhdGlvbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdjY2QtbG9hZGluZy1zcGlubmVyJyxcbiAgdGVtcGxhdGVVcmw6ICcuL2xvYWRpbmctc3Bpbm5lci5jb21wb25lbnQuaHRtbCcsXG4gIHN0eWxlVXJsczogWycuL2xvYWRpbmctc3Bpbm5lci5jb21wb25lbnQuc2NzcyddLFxuICBlbmNhcHN1bGF0aW9uOiBWaWV3RW5jYXBzdWxhdGlvbi5Ob25lXG59KVxuXG5leHBvcnQgY2xhc3MgTG9hZGluZ1NwaW5uZXJDb21wb25lbnQge1xuICBASW5wdXQoKSBwdWJsaWMgbG9hZGluZ1RleHQgPSAnTG9hZGluZyc7XG59XG4iLCI8ZGl2IGNsYXNzPVwic3Bpbm5lci1jb250YWluZXJcIj5cbiAgICA8ZGl2IGNsYXNzPVwic3Bpbm5lci1pbm5lci1jb250YWluZXJcIj5cbiAgICAgICAgPHA+e3tsb2FkaW5nVGV4dCB8IHJweFRyYW5zbGF0ZX19PC9wPlxuICAgICAgICA8ZGl2IGNsYXNzPVwic3Bpbm5lclwiIHN0eWxlPVwibWFyZ2luOiBhdXRvO1wiPjwvZGl2PlxuICAgIDwvZGl2PlxuPC9kaXY+XG4iXX0=

package/esm2020/lib/shared/components/loading-spinner/loading-spinner.module.mjs

@@ -0,0 +1,29 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { RpxTranslationModule } from 'rpx-xui-translation';
+import { LoadingSpinnerComponent } from './loading-spinner.component';
+import * as i0 from "@angular/core";
+import * as i1 from "rpx-xui-translation";
+export class LoadingSpinnerModule {
+}
+LoadingSpinnerModule.ɵfac = function LoadingSpinnerModule_Factory(t) { return new (t || LoadingSpinnerModule)(); };
+LoadingSpinnerModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: LoadingSpinnerModule });
+LoadingSpinnerModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [CommonModule,
+        RpxTranslationModule.forChild()] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LoadingSpinnerModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    CommonModule,
+                    RpxTranslationModule.forChild()
+                ],
+                declarations: [
+                    LoadingSpinnerComponent
+                ],
+                exports: [
+                    LoadingSpinnerComponent
+                ],
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(LoadingSpinnerModule, { declarations: [LoadingSpinnerComponent], imports: [CommonModule, i1.RpxTranslationModule], exports: [LoadingSpinnerComponent] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZGluZy1zcGlubmVyLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NjZC1jYXNlLXVpLXRvb2xraXQvc3JjL2xpYi9zaGFyZWQvY29tcG9uZW50cy9sb2FkaW5nLXNwaW5uZXIvbG9hZGluZy1zcGlubmVyLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUMzRCxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQzs7O0FBY3RFLE1BQU0sT0FBTyxvQkFBb0I7O3dGQUFwQixvQkFBb0I7c0VBQXBCLG9CQUFvQjswRUFWN0IsWUFBWTtRQUNaLG9CQUFvQixDQUFDLFFBQVEsRUFBRTt1RkFTdEIsb0JBQW9CO2NBWmhDLFFBQVE7ZUFBQztnQkFDUixPQUFPLEVBQUU7b0JBQ1AsWUFBWTtvQkFDWixvQkFBb0IsQ0FBQyxRQUFRLEVBQUU7aUJBQ2hDO2dCQUNELFlBQVksRUFBRTtvQkFDWix1QkFBdUI7aUJBQ3hCO2dCQUNELE9BQU8sRUFBRTtvQkFDUCx1QkFBdUI7aUJBQ3hCO2FBQ0Y7O3dGQUNZLG9CQUFvQixtQkFON0IsdUJBQXVCLGFBSnZCLFlBQVksc0NBT1osdUJBQXVCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBScHhUcmFuc2xhdGlvbk1vZHVsZSB9IGZyb20gJ3JweC14dWktdHJhbnNsYXRpb24nO1xuaW1wb3J0IHsgTG9hZGluZ1NwaW5uZXJDb21wb25lbnQgfSBmcm9tICcuL2xvYWRpbmctc3Bpbm5lci5jb21wb25lbnQnO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbXG4gICAgQ29tbW9uTW9kdWxlLFxuICAgIFJweFRyYW5zbGF0aW9uTW9kdWxlLmZvckNoaWxkKClcbiAgXSxcbiAgZGVjbGFyYXRpb25zOiBbXG4gICAgTG9hZGluZ1NwaW5uZXJDb21wb25lbnRcbiAgXSxcbiAgZXhwb3J0czogW1xuICAgIExvYWRpbmdTcGlubmVyQ29tcG9uZW50XG4gIF0sXG59KVxuZXhwb3J0IGNsYXNzIExvYWRpbmdTcGlubmVyTW9kdWxlIHsgfVxuIl19