@atlaskit/editor-plugin-tasks-and-decisions/dist/esm/ui/Task/task-item-with-providers.js

Tasks and decisions plugin for @atlaskit/editor-core

import _extends from "@babel/runtime/helpers/extends";
import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
import _createClass from "@babel/runtime/helpers/createClass";
import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
import _inherits from "@babel/runtime/helpers/inherits";
import _defineProperty from "@babel/runtime/helpers/defineProperty";
var _excluded = ["contextIdentifierProvider"];
import _regeneratorRuntime from "@babel/runtime/regenerator";
function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
import React, { Component } from 'react';
import { FabricElementsAnalyticsContext } from '@atlaskit/analytics-namespaced-context';
import { ResourcedTaskItem } from '@atlaskit/task-decision';
// eslint-disable-next-line @repo/internal/react/no-class-components
var TaskItemWithProviders = /*#__PURE__*/function (_Component) {
  function TaskItemWithProviders() {
    var _this;
    _classCallCheck(this, TaskItemWithProviders);
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }
    _this = _callSuper(this, TaskItemWithProviders, [].concat(args));
    _defineProperty(_this, "state", {
      resolvedContextProvider: undefined
    });
    // Storing the mounted state is an anti-pattern, however the asynchronous state
    // updates via `updateContextIdentifierProvider` means we may be dismounted before
    // it receives a response.
    // Since we can't cancel the Promise we store the mounted state to avoid state
    // updates when no longer suitable.
    _defineProperty(_this, "mounted", false);
    return _this;
  }
  _inherits(TaskItemWithProviders, _Component);
  return _createClass(TaskItemWithProviders, [{
    key: "componentDidMount",
    value: function componentDidMount() {
      this.mounted = true;
      this.updateContextIdentifierProvider(this.props);
    }
  }, {
    key: "componentDidUpdate",
    value: function componentDidUpdate(prevProps) {
      if (this.props.contextIdentifierProvider !== prevProps.contextIdentifierProvider) {
        this.updateContextIdentifierProvider(this.props);
      }
    }
  }, {
    key: "componentWillUnmount",
    value: function componentWillUnmount() {
      this.mounted = false;
    }
  }, {
    key: "updateContextIdentifierProvider",
    value: function () {
      var _updateContextIdentifierProvider = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(props) {
        var resolvedContextProvider;
        return _regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) switch (_context.prev = _context.next) {
            case 0:
              if (!props.contextIdentifierProvider) {
                _context.next = 13;
                break;
              }
              _context.prev = 1;
              _context.next = 4;
              return props.contextIdentifierProvider;
            case 4:
              resolvedContextProvider = _context.sent;
              if (this.mounted) {
                this.setState({
                  resolvedContextProvider: resolvedContextProvider
                });
              }
              _context.next = 11;
              break;
            case 8:
              _context.prev = 8;
              _context.t0 = _context["catch"](1);
              // eslint-disable-line no-unused-vars
              if (this.mounted) {
                this.setState({
                  resolvedContextProvider: undefined
                });
              }
            case 11:
              _context.next = 14;
              break;
            case 13:
              this.setState({
                resolvedContextProvider: undefined
              });
            case 14:
            case "end":
              return _context.stop();
          }
        }, _callee, this, [[1, 8]]);
      }));
      function updateContextIdentifierProvider(_x) {
        return _updateContextIdentifierProvider.apply(this, arguments);
      }
      return updateContextIdentifierProvider;
    }()
  }, {
    key: "render",
    value: function render() {
      var _this$props = this.props,
        _contextIdentifierProvider = _this$props.contextIdentifierProvider,
        otherProps = _objectWithoutProperties(_this$props, _excluded);
      var _ref = this.state.resolvedContextProvider || {},
        objectId = _ref.objectId;
      var userContext = objectId ? 'edit' : 'new';
      return /*#__PURE__*/React.createElement(FabricElementsAnalyticsContext
      // eslint-disable-next-line @atlassian/perf-linting/no-unstable-inline-props -- Ignored via go/ees017 (to be fixed)
      , {
        data: {
          userContext: userContext
        }
      }, /*#__PURE__*/React.createElement(ResourcedTaskItem
      // Ignored via go/ees005
      // eslint-disable-next-line react/jsx-props-no-spreading
      , _extends({}, otherProps, {
        objectAri: objectId
      })));
    }
  }]);
}(Component);
_defineProperty(TaskItemWithProviders, "displayName", 'TaskItemWithProviders');
export { TaskItemWithProviders as default };