@webex/contact-center 3.12.0-next.9 → 3.12.0-task-refactor.2

package/dist/services/task/Task.js

@@ -0,0 +1,644 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _events = require("events");
+var _xstate = require("xstate");
+var _types = require("./types");
+var _constants = require("./constants");
+var _constants2 = require("../../constants");
+var _Utils = require("../core/Utils");
+var _MetricsManager = _interopRequireDefault(require("../../metrics/MetricsManager"));
+var _constants3 = require("../../metrics/constants");
+var _loggerProxy = _interopRequireDefault(require("../../logger-proxy"));
+var _stateMachine = require("./state-machine");
+var _uiControlsComputer = require("./state-machine/uiControlsComputer");
+var _AutoWrapup = _interopRequireDefault(require("./AutoWrapup"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class Task extends _events.EventEmitter {
+  constructor(contact, data, uiControlConfig, wrapupData, agentId) {
+    super();
+    this.contact = contact;
+    this.data = data;
+    const channelType = uiControlConfig.channelType ?? Task.resolveChannelType(data);
+    // Include agentId in the config for ownership checks (transfer conference)
+    this.uiControlConfig = {
+      ...uiControlConfig,
+      channelType,
+      agentId
+    };
+    this.wrapupData = wrapupData;
+    this.agentId = agentId;
+    this.metricsManager = _MetricsManager.default.getInstance();
+    this.webCallMap = {};
+    this.currentUiControls = (0, _uiControlsComputer.getDefaultUIControls)();
+    this.initializeStateMachine();
+    this.setupAutoWrapupTimer();
+  }
+  static resolveChannelType(data) {
+    const mediaType = data?.interaction?.mediaType ?? _types.MEDIA_CHANNEL.TELEPHONY;
+    return mediaType === _types.MEDIA_CHANNEL.TELEPHONY ? _types.TASK_CHANNEL_TYPE.VOICE : _types.TASK_CHANNEL_TYPE.DIGITAL;
+  }
+
+  // Abstract methods that all child classes must implement
+
+  // Voice-specific methods with default implementations that throw errors
+  // Voice class will override these with actual implementations
+  async decline() {
+    this.unsupportedMethodError('decline');
+  }
+  async pauseRecording() {
+    this.unsupportedMethodError('pauseRecording');
+  }
+  async resumeRecording(resumeRecordingPayload) {
+    if (resumeRecordingPayload) {
+      // parameter intentionally unused
+    }
+    this.unsupportedMethodError('resumeRecording');
+  }
+  async consult(consultPayload) {
+    if (consultPayload) {
+      // parameter intentionally unused
+    }
+    this.unsupportedMethodError('consult');
+  }
+  async endConsult(consultEndPayload) {
+    if (consultEndPayload) {
+      // parameter intentionally unused
+    }
+    this.unsupportedMethodError('endConsult');
+  }
+  async consultTransfer(consultTransferPayload) {
+    if (consultTransferPayload) {
+      // parameter intentionally unused
+    }
+    this.unsupportedMethodError('consultTransfer');
+  }
+  async consultConference() {
+    this.unsupportedMethodError('consultConference');
+  }
+  async exitConference() {
+    this.unsupportedMethodError('exitConference');
+  }
+  async transferConference() {
+    this.unsupportedMethodError('transferConference');
+  }
+  async switchCall() {
+    this.unsupportedMethodError('switchCall');
+  }
+  async toggleMute() {
+    this.unsupportedMethodError('toggleMute');
+  }
+  unregisterWebCallListeners() {
+    // Default implementation - child classes can override
+    _loggerProxy.default.log('unregisterWebCallListeners called', {
+      module: _constants2.CC_FILE,
+      method: 'unregisterWebCallListeners',
+      interactionId: this.data?.interactionId
+    });
+  }
+
+  /**
+   * Cancel any in-progress auto wrap-up timer.
+   * Base implementation just clears the timer reference so subclasses inherit the behavior.
+   */
+  cancelAutoWrapupTimer() {
+    if (this.autoWrapup) {
+      this.autoWrapup.clear();
+      this.autoWrapup = undefined;
+      _loggerProxy.default.log('Auto wrap-up timer cancelled', {
+        module: _constants2.CC_FILE,
+        method: 'cancelAutoWrapupTimer',
+        interactionId: this.data?.interactionId
+      });
+    }
+  }
+
+  // Voice tasks use holdResume(), but provide separate methods for interface compliance
+  async hold() {
+    this.unsupportedMethodError('hold');
+  }
+  async resume() {
+    this.unsupportedMethodError('resume');
+  }
+  async holdResume() {
+    this.unsupportedMethodError('holdResume');
+  }
+
+  /**
+   * Latest UI controls derived from state machine state and context.
+   */
+  get uiControls() {
+    return this.currentUiControls;
+  }
+  updateUiControls(forceEmit = false) {
+    const nextControls = this.computeUIControls();
+    const shouldEmit = forceEmit || (0, _uiControlsComputer.haveUIControlsChanged)(this.currentUiControls, nextControls);
+    this.currentUiControls = nextControls;
+    if (shouldEmit) {
+      this.emit(_types.TASK_EVENTS.TASK_UI_CONTROLS_UPDATED, this.currentUiControls);
+    }
+  }
+
+  /**
+   * Initialize the state machine
+   */
+  initializeStateMachine() {
+    const machine = (0, _stateMachine.createTaskStateMachine)(this.uiControlConfig, {
+      actions: this.getStateMachineActionOverrides()
+    });
+    this.stateMachineService = (0, _xstate.createActor)(machine);
+    this.stateMachineService.subscribe(snapshot => {
+      const previousState = this.lastState;
+      const currentState = snapshot.value;
+      _loggerProxy.default.log(`State machine transition: ${previousState || 'N/A'} -> ${currentState}`, {
+        module: _constants2.CC_FILE,
+        method: 'onTransition',
+        // @ts-ignore - snapshot may include event detail depending on XState version
+        eventType: snapshot?.event?.type
+      });
+      this.lastState = currentState;
+      this.state = snapshot;
+      this.updateUiControls(previousState !== currentState);
+    });
+    this.stateMachineService.start();
+    this.updateUiControls(true);
+  }
+
+  /**
+   * Send an event to the state machine
+   */
+  sendStateMachineEvent(event) {
+    if (this.stateMachineService) {
+      _loggerProxy.default.log(`Sending state machine event: ${event?.type}`, {
+        module: _constants2.CC_FILE,
+        method: 'sendStateMachineEvent',
+        interactionId: this.data?.interactionId
+      });
+      this.stateMachineService.send(event);
+    }
+  }
+
+  /**
+   * Get the current state machine state
+   */
+  getCurrentState() {
+    return this.stateMachineService?.getSnapshot()?.value;
+  }
+
+  /**
+   * Compute UI controls based on current state machine state.
+   *
+   * @returns UI control states for all task actions
+   */
+  computeUIControls() {
+    const snapshot = this.stateMachineService?.getSnapshot?.();
+    if (!snapshot) {
+      return (0, _uiControlsComputer.getDefaultUIControls)();
+    }
+    const currentState = snapshot.value;
+    const context = snapshot.context;
+    return (0, _uiControlsComputer.computeUIControls)(currentState, context, this.data);
+  }
+
+  /**
+   * Stop the state machine service
+   */
+  stopStateMachine() {
+    if (this.stateMachineService) {
+      this.stateMachineService.stop();
+      this.stateMachineService = undefined;
+    }
+  }
+  static extractTaskDataFromEvent(event) {
+    if (!event || typeof event !== 'object') {
+      return undefined;
+    }
+    if ('taskData' in event) {
+      return event.taskData;
+    }
+    return undefined;
+  }
+  async autoAnswerIfNeeded() {
+    if (!this.data) {
+      return;
+    }
+    const autoAnswerSupported = this.uiControlConfig.channelType === _types.TASK_CHANNEL_TYPE.DIGITAL || this.uiControlConfig.voiceVariant === _types.VOICE_VARIANT.WEBRTC;
+    if (!autoAnswerSupported) {
+      return;
+    }
+    const shouldAutoAnswer = this.data.isAutoAnswering === true;
+    if (!shouldAutoAnswer) {
+      return;
+    }
+    _loggerProxy.default.info(`Auto-answering task`, {
+      module: _constants2.TASK_FILE,
+      method: 'autoAnswerIfNeeded',
+      interactionId: this.data.interactionId
+    });
+    try {
+      await this.accept();
+      _loggerProxy.default.info(`Task auto-answered successfully`, {
+        module: _constants2.TASK_FILE,
+        method: 'autoAnswerIfNeeded',
+        interactionId: this.data.interactionId
+      });
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_AUTO_ANSWER_SUCCESS, {
+        taskId: this.data.interactionId,
+        mediaType: this.data.interaction.mediaType,
+        isAutoAnswered: true
+      }, ['behavioral', 'operational']);
+      this.emit(_types.TASK_EVENTS.TASK_AUTO_ANSWERED, this);
+    } catch (error) {
+      this.updateTaskData({
+        ...this.data,
+        isAutoAnswering: false
+      });
+      _loggerProxy.default.error(`Failed to auto-answer task`, {
+        module: _constants2.TASK_FILE,
+        method: 'autoAnswerIfNeeded',
+        interactionId: this.data.interactionId,
+        error
+      });
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_AUTO_ANSWER_FAILED, {
+        taskId: this.data.interactionId,
+        mediaType: this.data.interaction.mediaType,
+        error: error?.message || 'Unknown error',
+        isAutoAnswered: false
+      }, ['behavioral', 'operational']);
+    }
+  }
+  updateTaskFromEvent(event) {
+    const taskData = Task.extractTaskDataFromEvent(event);
+    if (taskData) {
+      this.updateTaskData(taskData);
+    }
+  }
+  getStateMachineActionOverrides() {
+    return {
+      ...this.getCommonActionOverrides(),
+      ...this.getChannelSpecificActionOverrides()
+    };
+  }
+  getChannelSpecificActionOverrides() {
+    return {};
+  }
+  createEmitSelfAction(taskEvent, {
+    updateTaskData = false
+  } = {}) {
+    return ({
+      event
+    }) => {
+      if (updateTaskData) {
+        this.updateTaskFromEvent(event);
+      }
+      _loggerProxy.default.info(`Emitting task event ${taskEvent}`, {
+        module: _constants2.TASK_FILE,
+        method: 'emitTaskEvent',
+        interactionId: this.data?.interactionId
+      });
+      this.emit(taskEvent, this);
+    };
+  }
+  getCommonActionOverrides() {
+    return {
+      syncTaskDataFromEvent: ({
+        event
+      }) => {
+        this.updateTaskFromEvent(event);
+      },
+      emitTaskIncoming: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_INCOMING, {
+        updateTaskData: true
+      }),
+      emitTaskHydrate: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_HYDRATE, {
+        updateTaskData: true
+      }),
+      emitTaskOfferContact: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_OFFER_CONTACT, {
+        updateTaskData: true
+      }),
+      emitTaskAssigned: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_ASSIGNED, {
+        updateTaskData: true
+      }),
+      emitTaskEnd: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_END, {
+        updateTaskData: true
+      }),
+      emitTaskOfferConsult: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_OFFER_CONSULT, {
+        updateTaskData: true
+      }),
+      emitTaskConsultCreated: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_CONSULT_CREATED, {
+        updateTaskData: true
+      }),
+      emitTaskConsulting: ({
+        event
+      }) => {
+        this.updateTaskFromEvent(event);
+        if (this.data.isConsulted) {
+          this.emit(_types.TASK_EVENTS.TASK_CONSULT_ACCEPTED, this);
+        } else {
+          this.emit(_types.TASK_EVENTS.TASK_CONSULTING, this);
+        }
+      },
+      emitTaskConsultAccepted: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_CONSULT_ACCEPTED),
+      emitTaskConsultEnd: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_CONSULT_END, {
+        updateTaskData: true
+      }),
+      emitTaskConsultQueueCancelled: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_CONSULT_QUEUE_CANCELLED, {
+        updateTaskData: true
+      }),
+      emitTaskConsultQueueFailed: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_CONSULT_QUEUE_FAILED, {
+        updateTaskData: true
+      }),
+      emitTaskReject: ({
+        event
+      }) => {
+        this.updateTaskFromEvent(event);
+        const reason = event && typeof event === 'object' && 'reason' in event ? event.reason : undefined;
+        this.emit(_types.TASK_EVENTS.TASK_REJECT, reason);
+      },
+      emitTaskWrapup: ({
+        event
+      }) => {
+        this.updateTaskFromEvent(event);
+        const shouldEmitWrapup = Boolean(this.data.wrapUpRequired);
+        if (!shouldEmitWrapup) {
+          _loggerProxy.default.info(`Skipping task:wrapup event - wrapUpRequired is false`, {
+            module: _constants2.TASK_FILE,
+            method: 'emitTaskEvent',
+            interactionId: this.data?.interactionId
+          });
+          return;
+        }
+        _loggerProxy.default.info(`Emitting task event ${_types.TASK_EVENTS.TASK_WRAPUP}`, {
+          module: _constants2.TASK_FILE,
+          method: 'emitTaskEvent',
+          interactionId: this.data?.interactionId
+        });
+        this.emit(_types.TASK_EVENTS.TASK_WRAPUP, this);
+      },
+      emitTaskWrappedup: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_WRAPPEDUP, {
+        updateTaskData: true
+      }),
+      requestAutoAnswer: ({
+        event
+      }) => {
+        if (event) {
+          // parameter intentionally unused
+        }
+        this.autoAnswerIfNeeded();
+      },
+      requestCleanup: () => {
+        this.emit(_types.TASK_EVENTS.TASK_CLEANUP, this, {
+          removeFromCollection: false
+        });
+      },
+      cleanupResources: () => {
+        this.emit(_types.TASK_EVENTS.TASK_CLEANUP, this, {
+          removeFromCollection: true
+        });
+      }
+    };
+  }
+
+  /**
+   * Sets up the automatic wrap-up timer if wrap-up is required
+   */
+  setupAutoWrapupTimer() {
+    if (this.data.wrapUpRequired && !this.autoWrapup && this.wrapupData && this.wrapupData.wrapUpProps) {
+      const wrapUpProps = this.wrapupData.wrapUpProps;
+      if (!wrapUpProps || wrapUpProps.autoWrapup === false) {
+        _loggerProxy.default.info(`Auto wrap-up is not required for this task`, {
+          module: _constants2.TASK_FILE,
+          method: _constants.METHODS.SETUP_AUTO_WRAPUP_TIMER,
+          interactionId: this.data.interactionId
+        });
+        return;
+      }
+      const defaultWrapupReason = wrapUpProps.wrapUpReasonList?.find(r => r.isDefault) ?? wrapUpProps.wrapUpReasonList?.[0];
+      if (!defaultWrapupReason) {
+        _loggerProxy.default.error('No wrap-up reason configured', {
+          module: _constants2.TASK_FILE,
+          method: _constants.METHODS.SETUP_AUTO_WRAPUP_TIMER
+        });
+        return;
+      }
+      const intervalMs = wrapUpProps.autoWrapupInterval;
+      if (!intervalMs || intervalMs <= 0) {
+        _loggerProxy.default.error(`Invalid auto wrap-up interval: ${intervalMs}`, {
+          module: _constants2.TASK_FILE,
+          method: _constants.METHODS.SETUP_AUTO_WRAPUP_TIMER
+        });
+        return;
+      }
+      this.autoWrapup = new _AutoWrapup.default(intervalMs, wrapUpProps.allowCancelAutoWrapup);
+      this.autoWrapup.start(async () => {
+        _loggerProxy.default.info(`Auto wrap-up timer triggered`, {
+          module: _constants2.TASK_FILE,
+          method: _constants.METHODS.SETUP_AUTO_WRAPUP_TIMER,
+          interactionId: this.data.interactionId
+        });
+        await this.wrapup({
+          wrapUpReason: defaultWrapupReason.name,
+          auxCodeId: defaultWrapupReason.id
+        });
+      });
+    }
+  }
+
+  /**
+   * Cancels the automatic wrap-up timer if it's running
+   */
+  reconcileData(oldData, newData) {
+    Object.keys(newData).forEach(key => {
+      if (newData[key] && typeof newData[key] === 'object' && !Array.isArray(newData[key])) {
+        oldData[key] = this.reconcileData({
+          ...oldData[key]
+        }, newData[key]);
+      } else {
+        oldData[key] = newData[key];
+      }
+    });
+    return oldData;
+  }
+
+  /**
+   *
+   * @param methodName - The name of the method that is unsupported
+   * @throws Error
+   */
+  unsupportedMethodError(methodName) {
+    _loggerProxy.default.error(`Unsupported operation`, {
+      module: 'TASK',
+      method: methodName,
+      interactionId: this.data?.interactionId
+    });
+    throw new Error(`Unsupported operation: ${methodName}`);
+  }
+
+  /**
+   * This method is used to update the task data.
+   * @param updatedData - TaskData
+   * @param shouldOverwrite - boolean
+   * @example
+   * ```typescript
+   * task.updateTaskData(updatedData, true);
+   * ```
+   */
+  updateTaskData(updatedData, shouldOverwrite = false) {
+    this.data = shouldOverwrite ? updatedData : this.reconcileData(this.data, updatedData);
+    this.updateUiControls();
+    this.setupAutoWrapupTimer();
+    return this;
+  }
+
+  /**
+   * This is used to blind transfer or vTeam transfer the task
+   * @param transferPayload
+   * @returns Promise<TaskResponse>
+   * @throws Error
+   * @example
+   * ```typescript
+   * const transferPayload = {
+   *  to: 'myQueueId',
+   *  destinationType: 'queue',
+   * }
+   * task.transfer(transferPayload).then(()=>{}).catch(()=>{});
+   * ```
+   */
+  async transfer(transferPayload) {
+    _loggerProxy.default.log(`Starting task transfer for taskId:${this.data.interactionId}`, {
+      module: 'Task',
+      method: 'transfer'
+    });
+    try {
+      this.metricsManager.timeEvent([_constants3.METRIC_EVENT_NAMES.TASK_TRANSFER_SUCCESS, _constants3.METRIC_EVENT_NAMES.TASK_TRANSFER_FAILED]);
+      let result;
+      if (transferPayload.destinationType === _types.DESTINATION_TYPE.QUEUE) {
+        result = await this.contact.vteamTransfer({
+          interactionId: this.data.interactionId,
+          data: transferPayload
+        });
+      } else {
+        result = await this.contact.blindTransfer({
+          interactionId: this.data.interactionId,
+          data: transferPayload
+        });
+      }
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_TRANSFER_SUCCESS, {
+        taskId: this.data.interactionId,
+        destination: transferPayload.to,
+        destinationType: transferPayload.destinationType,
+        isConsultTransfer: false,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(result)
+      }, ['operational', 'behavioral', 'business']);
+      return result;
+    } catch (error) {
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, 'transfer', _constants2.CC_FILE);
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_TRANSFER_FAILED, {
+        taskId: this.data.interactionId,
+        destination: transferPayload.to,
+        destinationType: transferPayload.destinationType,
+        isConsultTransfer: false,
+        error: error.toString(),
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral', 'business']);
+      throw detailedError;
+    }
+  }
+
+  /**
+   * This is used to end the task.
+   * @returns Promise<TaskResponse>
+   * @throws Error
+   * @example
+   * ```typescript
+   * task.end().then(()=>{}).catch(()=>{})
+   *  ```
+   */
+  async end() {
+    _loggerProxy.default.log(`Ending task for taskId:${this.data.interactionId}`, {
+      module: 'Task',
+      method: 'end'
+    });
+    const requestInteractionId = this.data.interaction?.mainInteractionId || this.data.interactionId;
+    try {
+      this.metricsManager.timeEvent([_constants3.METRIC_EVENT_NAMES.TASK_END_SUCCESS, _constants3.METRIC_EVENT_NAMES.TASK_END_FAILED]);
+      const response = await this.contact.end({
+        interactionId: requestInteractionId
+      });
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_END_SUCCESS, {
+        taskId: this.data.interactionId,
+        requestInteractionId,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(response)
+      }, ['operational', 'behavioral', 'business']);
+      return response;
+    } catch (error) {
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, 'end', _constants2.CC_FILE);
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_END_FAILED, {
+        taskId: this.data.interactionId,
+        requestInteractionId,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral', 'business']);
+      throw detailedError;
+    }
+  }
+
+  /**
+   * This is used to wrap up the task.
+   * @param wrapupPayload - WrapupPayLoad
+   * @returns Promise<TaskResponse>
+   * @throws Error
+   * @example
+   * ```typescript
+   * task.wrapup(wrapupPayload).then(()=>{}).catch(()=>{})
+   * ```
+   */
+  async wrapup(wrapupPayload) {
+    this.cancelAutoWrapupTimer();
+    _loggerProxy.default.log(`Starting task wrapup for taskId:${this.data.interactionId}`, {
+      module: 'Task',
+      method: 'wrapup'
+    });
+    try {
+      this.metricsManager.timeEvent([_constants3.METRIC_EVENT_NAMES.TASK_WRAPUP_SUCCESS, _constants3.METRIC_EVENT_NAMES.TASK_WRAPUP_FAILED]);
+      if (!this.data) {
+        throw new Error('No task data available');
+      }
+      if (!wrapupPayload.auxCodeId || wrapupPayload.auxCodeId.length === 0) {
+        throw new Error('AuxCodeId is required');
+      }
+      if (!wrapupPayload.wrapUpReason || wrapupPayload.wrapUpReason.length === 0) {
+        throw new Error('WrapUpReason is required');
+      }
+      const response = await this.contact.wrapup({
+        interactionId: this.data.interactionId,
+        data: wrapupPayload
+      });
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_WRAPUP_SUCCESS, {
+        taskId: this.data.interactionId,
+        wrapUpCode: wrapupPayload.auxCodeId,
+        wrapUpReason: wrapupPayload.wrapUpReason,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(response)
+      }, ['operational', 'behavioral', 'business']);
+      return response;
+    } catch (error) {
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, 'wrapup', _constants2.CC_FILE);
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_WRAPUP_FAILED, {
+        taskId: this.data.interactionId,
+        wrapUpCode: wrapupPayload.auxCodeId,
+        wrapUpReason: wrapupPayload.wrapUpReason,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral', 'business']);
+      throw detailedError;
+    }
+  }
+}
+exports.default = Task;
+//# sourceMappingURL=Task.js.map