@instructure/outcomes-ui 2.1.4 → 2.1.6

package/lib/translated/fi/util/__tests__/flashAlertUtils.test.js

@@ -0,0 +1,66 @@
+"use strict";
+
+var _chai = require("chai");
+
+var _flashAlertUtils = require("../flashAlertUtils.js");
+
+describe('findDetailMessage', function () {
+  it('returns just the message if there is no response', function () {
+    var error = {
+      message: 'Error!'
+    };
+    (0, _chai.expect)((0, _flashAlertUtils.findDetailMessage)(error)).to.deep.eq({
+      a: error.message,
+      b: void 0
+    });
+  });
+  it('returns both messages if errors is not an array', function () {
+    var error = {
+      message: 'Error!',
+      response: {
+        data: {
+          message: 'Message!',
+          errors: ''
+        }
+      }
+    };
+    (0, _chai.expect)((0, _flashAlertUtils.findDetailMessage)(error)).to.deep.eq({
+      a: error.response.data.message,
+      b: error.message
+    });
+  });
+  it('returns the message and first error if errors is an array', function () {
+    var error = {
+      message: 'Error!',
+      response: {
+        data: {
+          message: 'Message!',
+          errors: [{
+            message: 'First error!'
+          }, {
+            message: 'Second error!'
+          }]
+        }
+      }
+    };
+    (0, _chai.expect)((0, _flashAlertUtils.findDetailMessage)(error)).to.deep.eq({
+      a: error.response.data.errors[0].message,
+      b: error.message
+    });
+  });
+});
+describe('isLoadingChunkError', function () {
+  it('returns true if the string contains loading chunk text', function () {
+    (0, _chai.expect)((0, _flashAlertUtils.isLoadingChunkError)('loading chunk')).to.be.true;
+    (0, _chai.expect)((0, _flashAlertUtils.isLoadingChunkError)('loading chunk error')).to.be.true;
+    (0, _chai.expect)((0, _flashAlertUtils.isLoadingChunkError)('error loading chunk')).to.be.true;
+  });
+  it('returns false if the string does not contain loading chunk text', function () {
+    (0, _chai.expect)((0, _flashAlertUtils.isLoadingChunkError)('loading')).to.be.false;
+    (0, _chai.expect)((0, _flashAlertUtils.isLoadingChunkError)('chunk')).to.be.false;
+    (0, _chai.expect)((0, _flashAlertUtils.isLoadingChunkError)('error loading')).to.be.false;
+    (0, _chai.expect)((0, _flashAlertUtils.isLoadingChunkError)('loading error')).to.be.false;
+    (0, _chai.expect)((0, _flashAlertUtils.isLoadingChunkError)('error chunk')).to.be.false;
+    (0, _chai.expect)((0, _flashAlertUtils.isLoadingChunkError)('chunk error')).to.be.false;
+  });
+});

package/lib/translated/fi/util/__tests__/outcomesReportUtils.test.js

@@ -0,0 +1,109 @@
+"use strict";
+
+var _chai = require("chai");
+
+var _outcomesReportUtils = require("../outcomesReportUtils.js");
+
+var _constants = require("../../constants.js");
+
+var user1 = {
+  uuid: 'user1-uuid',
+  full_name: 'Student 1'
+};
+var user2 = {
+  uuid: 'user2-uuid',
+  full_name: 'Student 2'
+};
+var rollup = {
+  outcomeId: '1',
+  childArtifactCount: 1,
+  usesBank: false
+};
+var outcome = {
+  id: '1',
+  guid: 'outcome-guid',
+  group: false,
+  label: 'outcome friendly name',
+  title: 'outcome name',
+  description: 'outcome description',
+  external_id: 10,
+  scoring_method: {
+    algorithm: 'average',
+    algorithm_data: {},
+    mastery_percent: 0.6,
+    points_possible: 5
+  }
+};
+var masteryResult = {
+  userId: user1.uuid,
+  percentScore: 0.6667,
+  points: 2,
+  pointsPossible: 3,
+  attempt: 1
+};
+var nonMasteryResult = {
+  userId: user2.uuid,
+  percentScore: 0.3333,
+  points: 1,
+  pointsPossible: 3,
+  attempt: 1
+};
+describe('outcomesReportUtils', function () {
+  describe('formatDataInRow', function () {
+    it('returns the correct value for each row header', function () {
+      var formattedRow = (0, _outcomesReportUtils.formatDataIntoRow)(user1, outcome, rollup, masteryResult);
+      (0, _chai.expect)(formattedRow[_constants.STUDENT_NAME]).to.eq(user1.full_name);
+      (0, _chai.expect)(formattedRow[_constants.STUDENT_UUID]).to.eq(user1.uuid);
+      (0, _chai.expect)(formattedRow[_constants.ATTEMPT_COUNT]).to.eq(masteryResult.attempt);
+      (0, _chai.expect)(formattedRow[_constants.ALIGNED_QUESTIONS_COUNT]).to.eq(rollup.childArtifactCount);
+      (0, _chai.expect)(formattedRow[_constants.LOR_POINTS]).to.eq(masteryResult.points);
+      (0, _chai.expect)(formattedRow[_constants.LOR_POINTS_POSSIBLE]).to.eq(masteryResult.pointsPossible);
+      (0, _chai.expect)(formattedRow[_constants.LO_NAME]).to.eq(outcome.title);
+      (0, _chai.expect)(formattedRow[_constants.LO_ID]).to.eq(outcome.id);
+      (0, _chai.expect)(formattedRow[_constants.LO_MASTERY_PERCENT]).to.eq(outcome.scoring_method.mastery_percent);
+      (0, _chai.expect)(formattedRow[_constants.LO_MASTERED]).to.be.true;
+      (0, _chai.expect)(Object.keys(formattedRow).length).eq(10);
+    });
+    describe('for aligned questions count row', function () {
+      it('returns Variable Questions for aligned questions count if a bank was used', function () {
+        var usesBank = {
+          outcomeId: '1',
+          usesBank: true
+        };
+        var formattedRow = (0, _outcomesReportUtils.formatDataIntoRow)(user1, outcome, usesBank, masteryResult);
+        (0, _chai.expect)(formattedRow[_constants.ALIGNED_QUESTIONS_COUNT]).to.eq('Variable Questions');
+      });
+    });
+  });
+  describe('hasMastery', function () {
+    it('returns true if the student achieved mastery for the given outcome', function () {
+      (0, _chai.expect)((0, _outcomesReportUtils.hasMastery)(masteryResult, outcome)).to.be.true;
+    });
+    it('returns false if the student did not reach mastery for the given outcome', function () {
+      (0, _chai.expect)((0, _outcomesReportUtils.hasMastery)(nonMasteryResult, outcome)).to.be.false;
+    });
+  });
+  describe('fileName', function () {
+    it('returns the file name for the csv report', function () {
+      var name = (0, _outcomesReportUtils.fileName)(1);
+      (0, _chai.expect)(name.includes('outcome_analysis_csv_')).to.be.true;
+      (0, _chai.expect)(name.includes('_quiz_1.csv')).to.be.true;
+    });
+  });
+  describe('getDate', function () {
+    // Regex for yyyy-mm-dd format was found here:
+    // https://stackoverflow.com/questions/22061723/regex-date-validation-for-yyyy-mm-dd
+    it('returns the date in yyyy-mm-dd format', function () {
+      (0, _chai.expect)((0, _outcomesReportUtils.getDate)().match(/^\d{4}-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])$/)).not.to.empty;
+    });
+  });
+  describe('formatPercentage', function () {
+    it('formats two numbers into a percentage', function () {
+      (0, _chai.expect)((0, _outcomesReportUtils.formatPercentage)(50, 100)).to.eq(50);
+      (0, _chai.expect)((0, _outcomesReportUtils.formatPercentage)(5, 10)).to.eq(50);
+    });
+    it('formats two numbers into a percentage and rounds', function () {
+      (0, _chai.expect)((0, _outcomesReportUtils.formatPercentage)(1, 3)).to.eq(33);
+    });
+  });
+});

package/lib/translated/fi/util/flashAlertUtils.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findDetailMessage = findDetailMessage;
+exports.isLoadingChunkError = void 0;
+
+function findDetailMessage(err) {
+  var a = err.message;
+  var b;
+
+  if (err.response) {
+    if (err.response.data) {
+      try {
+        if (Array.isArray(err.response.data.errors)) {
+          // probably a canvas api
+          a = err.response.data.errors[0].message;
+          b = err.message;
+        } else if (err.response.data.message) {
+          // probably a canvas api too
+          a = err.response.data.message;
+          b = err.message;
+        }
+      } catch (ignore) {
+        a = err.message;
+      }
+    }
+  }
+
+  return {
+    a: a,
+    b: b
+  };
+}
+
+var isLoadingChunkError = function isLoadingChunkError(a) {
+  return typeof a === 'string' && a.toLowerCase().includes('loading chunk');
+};
+
+exports.isLoadingChunkError = isLoadingChunkError;

package/lib/translated/fi/util/outcomesReportUtils.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatPercentage = exports.getDate = exports.fileName = exports.hasMastery = exports.formatDataIntoRow = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _constants = require("../constants.js");
+
+var formatDataIntoRow = function formatDataIntoRow(user, outcome, rollup, result) {
+  var _ref;
+
+  return _ref = {}, (0, _defineProperty2.default)(_ref, _constants.STUDENT_NAME, user.full_name), (0, _defineProperty2.default)(_ref, _constants.STUDENT_UUID, user.uuid), (0, _defineProperty2.default)(_ref, _constants.ATTEMPT_COUNT, result.attempt), (0, _defineProperty2.default)(_ref, _constants.ALIGNED_QUESTIONS_COUNT, getAlignedQuestionsCount(rollup)), (0, _defineProperty2.default)(_ref, _constants.LOR_POINTS, result.points), (0, _defineProperty2.default)(_ref, _constants.LOR_POINTS_POSSIBLE, result.pointsPossible), (0, _defineProperty2.default)(_ref, _constants.LO_NAME, outcome.title), (0, _defineProperty2.default)(_ref, _constants.LO_ID, outcome.id), (0, _defineProperty2.default)(_ref, _constants.LO_MASTERY_PERCENT, outcome.scoring_method.mastery_percent), (0, _defineProperty2.default)(_ref, _constants.LO_MASTERED, hasMastery(result, outcome)), _ref;
+};
+
+exports.formatDataIntoRow = formatDataIntoRow;
+
+var hasMastery = function hasMastery(result, outcome) {
+  return result && result.percentScore >= outcome.scoring_method.mastery_percent;
+};
+
+exports.hasMastery = hasMastery;
+
+var fileName = function fileName(id) {
+  var date = getDate();
+  return "outcome_analysis_csv_".concat(date, "_quiz_").concat(id, ".csv");
+};
+
+exports.fileName = fileName;
+
+var getDate = function getDate() {
+  // Found this solution on stackoverflow:
+  // https://stackoverflow.com/questions/23593052/format-javascript-date-as-yyyy-mm-dd
+  var now = new Date(Date.now());
+  var offset = now.getTimezoneOffset();
+  return new Date(now.getTime() - offset * 60 * 1000).toISOString().split('T')[0];
+};
+
+exports.getDate = getDate;
+
+var formatPercentage = function formatPercentage(value, maxValue) {
+  return Math.round(value / maxValue * 100);
+}; // Note: Once OS has Item Bank alignments, this will need to be updated
+
+
+exports.formatPercentage = formatPercentage;
+
+var getAlignedQuestionsCount = function getAlignedQuestionsCount(rollup) {
+  return rollup.usesBank ? "Vaihtelevat kysymykset" : rollup.childArtifactCount;
+};

package/lib/translated/fr/components/AlignmentItem/__tests__/index.test.js

@@ -35,7 +35,7 @@ describe('AlignmentItem', function () {
 
   it('renders title', function () {
     var wrapper = (0, _enzyme.shallow)( /*#__PURE__*/_react.default.createElement(_index.default, makeProps()));
-    (0, _chai.expect)(wrapper.find('Text')).to.have.length(1);
+    (0, _chai.expect)(wrapper.find('Heading')).to.have.length(1);
   });
   it('renders the friendly name if user cannot manage outcomes', function () {
     var wrapper = (0, _enzyme.mount)( /*#__PURE__*/_react.default.createElement(_index.default, makeProps({

package/lib/translated/fr/components/AlignmentItem/index.js

@@ -19,6 +19,8 @@ var _uiCheckbox = require("@instructure/ui-checkbox");
 
 var _uiFlex = require("@instructure/ui-flex");
 
+var _uiHeading = require("@instructure/ui-heading");
+
 var _uiText = require("@instructure/ui-text");
 
 var _uiIcons = require("@instructure/ui-icons");
@@ -84,6 +86,7 @@ var AlignmentItem = function AlignmentItem(_ref) {
       showTooltip = _useBoolean2[1],
       hideTooltip = _useBoolean2[2];
 
+  var displayTitle = !canManageOutcomes && label ? label : title;
   (0, _react.useEffect)(function () {
     if (shouldFocus) {
       var _trashIconRef$current;
@@ -100,14 +103,6 @@ var AlignmentItem = function AlignmentItem(_ref) {
     }
   };
 
-  var renderTitleText = function renderTitleText(size, weight) {
-    return /*#__PURE__*/_react.default.createElement(_uiText.Text, {
-      size: size,
-      weight: weight,
-      wrap: "break-word"
-    }, !canManageOutcomes && label ? label : title);
-  };
-
   var handleUpdate = function handleUpdate(isTruncated) {
     if (titleTruncated !== isTruncated) {
       setTitleTruncated(isTruncated);
@@ -120,10 +115,22 @@ var AlignmentItem = function AlignmentItem(_ref) {
         padding: isTray ? '0.5rem 0' : '0.4rem 0 0 0.3rem'
       },
       "data-automation": "alignmentItem__outcomeName"
-    }, truncated ? /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement(_uiTruncateText.TruncateText, {
+    }, truncated ? /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement(_uiHeading.Heading, {
+      level: "h4",
+      as: "h2",
+      theme: {
+        lineHeight: '1.5rem'
+      }
+    }, /*#__PURE__*/_react.default.createElement(_uiTruncateText.TruncateText, {
       position: "middle",
       onUpdate: handleUpdate
-    }, renderTitleText('medium', 'bold'), /*#__PURE__*/_react.default.createElement("span", null))) : renderTitleText('medium', 'bold'));
+    }, displayTitle, /*#__PURE__*/_react.default.createElement("span", null)))) : /*#__PURE__*/_react.default.createElement(_uiHeading.Heading, {
+      level: "h4",
+      as: "h2",
+      theme: {
+        lineHeight: '1.5rem'
+      }
+    }, displayTitle));
   };
 
   var renderDeleteButton = function renderDeleteButton() {
@@ -203,7 +210,11 @@ var AlignmentItem = function AlignmentItem(_ref) {
     as: "div",
     maxWidth: "19rem",
     padding: "small"
-  }, renderTitleText('small', 'normal'))) : renderOutcomeTitle()), canManageOutcomes && !isTray && /*#__PURE__*/_react.default.createElement(_uiFlex.Flex.Item, null, renderDeleteButton())), /*#__PURE__*/_react.default.createElement(_uiFlex.Flex, {
+  }, /*#__PURE__*/_react.default.createElement(_uiText.Text, {
+    size: "small",
+    weight: "normal",
+    wrap: "break-word"
+  }, displayTitle))) : renderOutcomeTitle()), canManageOutcomes && !isTray && /*#__PURE__*/_react.default.createElement(_uiFlex.Flex.Item, null, renderDeleteButton())), /*#__PURE__*/_react.default.createElement(_uiFlex.Flex, {
     as: "div",
     alignItems: "start"
   }, /*#__PURE__*/_react.default.createElement(_uiFlex.Flex.Item, {

package/lib/translated/fr/components/FlashAlert/index.js

@@ -0,0 +1,264 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.showFlashAlert = showFlashAlert;
+exports.destroyContainer = destroyContainer;
+exports.showFlashError = showFlashError;
+exports.showFlashSuccess = showFlashSuccess;
+exports.default = exports.defaultTimeout = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _reactDom = _interopRequireDefault(require("react-dom"));
+
+var _uiAlerts = require("@instructure/ui-alerts");
+
+var _uiLink = require("@instructure/ui-link");
+
+var _uiText = require("@instructure/ui-text");
+
+var _uiA11yContent = require("@instructure/ui-a11y-content");
+
+var _uiMotion = require("@instructure/ui-motion");
+
+var _flashAlertUtils = require("../../util/flashAlertUtils.js");
+
+/*
+ * Note: This file is copied over from canvas-lms/ui/shared/alerts/react/FlashAlert.js
+ * It has a few minor changes so that it works with outcomes-ui, but is overall
+ * pretty much the same and it works the same. Some functions were moved into a utils
+ * file for testing purposes.
+ */
+var messageHolderId = 'flashalert_message_holder'; // specs fail if I reuse jquery's elements
+
+var screenreaderMessageHolderId = 'flash_screenreader_holder';
+var defaultTimeout = 10000;
+exports.defaultTimeout = defaultTimeout;
+
+function showFlashAlert(_ref) {
+  var message = _ref.message,
+      err = _ref.err,
+      _ref$type = _ref.type,
+      type = _ref$type === void 0 ? err ? 'error' : 'info' : _ref$type,
+      _ref$timeout = _ref.timeout,
+      timeout = _ref$timeout === void 0 ? defaultTimeout : _ref$timeout,
+      _ref$srOnly = _ref.srOnly,
+      srOnly = _ref$srOnly === void 0 ? false : _ref$srOnly;
+
+  function closeAlert(atNode) {
+    _reactDom.default.unmountComponentAtNode(atNode);
+
+    atNode.remove();
+  }
+
+  function getAlertContainer() {
+    var alertContainer = document.getElementById(messageHolderId);
+
+    if (!alertContainer) {
+      alertContainer = document.createElement('div');
+      alertContainer.classList.add('clickthrough-container');
+      alertContainer.id = messageHolderId;
+      alertContainer.setAttribute('style', 'position: fixed; top: 0; left: 0; width: 100%; z-index: 100000;');
+      document.body.appendChild(alertContainer);
+    }
+
+    return alertContainer;
+  }
+
+  function renderAlert(parent) {
+    _reactDom.default.render( /*#__PURE__*/_react.default.createElement(FlashAlert, {
+      message: message,
+      timeout: timeout,
+      error: err,
+      variant: type,
+      onClose: closeAlert.bind(null, parent),
+      screenReaderOnly: srOnly
+    }), parent);
+  }
+
+  var div = document.createElement('div'); // div.setAttribute('class', styles.flashMessage)
+
+  div.setAttribute('style', 'max-width:50em;margin:1rem auto;');
+  div.setAttribute('class', 'flashalert-message');
+  getAlertContainer().appendChild(div);
+  renderAlert(div);
+}
+
+function destroyContainer() {
+  var container = document.getElementById(messageHolderId);
+  var liveRegion = document.getElementById(screenreaderMessageHolderId);
+  if (container) container.remove();
+  if (liveRegion) liveRegion.remove();
+}
+
+function showFlashError() {
+  var message = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "An error occurred making a network request";
+  return function (err) {
+    return showFlashAlert({
+      message: message,
+      err: err,
+      type: 'error'
+    });
+  };
+}
+
+function showFlashSuccess(message) {
+  return function () {
+    return showFlashAlert({
+      message: message,
+      type: 'success'
+    });
+  };
+} // An Alert with a message and "Details" button which surfaces
+// more info about the error when pressed.
+// Is displayed at the top of the document, and will close itself after a while
+
+
+var FlashAlert = /*#__PURE__*/function (_React$Component) {
+  (0, _inherits2.default)(FlashAlert, _React$Component);
+
+  var _super = (0, _createSuper2.default)(FlashAlert);
+
+  function FlashAlert(props) {
+    var _this;
+
+    (0, _classCallCheck2.default)(this, FlashAlert);
+    _this = _super.call(this, props);
+
+    _this.showDetails = function () {
+      _this.setState({
+        showDetails: true
+      });
+
+      clearTimeout(_this.timerId);
+      _this.timerId = setTimeout(function () {
+        return _this.closeAlert();
+      }, _this.props.timeout);
+    };
+
+    _this.closeAlert = function () {
+      _this.setState({
+        isOpen: false
+      }, function () {
+        setTimeout(function () {
+          clearTimeout(_this.timerId);
+
+          _this.props.onClose();
+        }, 500);
+      });
+    };
+
+    _this.state = {
+      showDetails: false,
+      isOpen: true
+    };
+    _this.timerId = 0;
+    return _this;
+  }
+
+  (0, _createClass2.default)(FlashAlert, [{
+    key: "getLiveRegion",
+    value: function getLiveRegion() {
+      // return element where flash screenreader messages go.
+      // create if necessary
+      var liveRegion = document.getElementById(screenreaderMessageHolderId);
+
+      if (!liveRegion) {
+        liveRegion = document.createElement('div');
+        liveRegion.id = screenreaderMessageHolderId;
+        liveRegion.setAttribute('role', 'alert');
+        document.body.appendChild(liveRegion);
+      }
+
+      return liveRegion;
+    }
+  }, {
+    key: "renderDetailMessage",
+    value: function renderDetailMessage(a, b) {
+      var showPrimaryDetails = a && !(0, _flashAlertUtils.isLoadingChunkError)(a);
+      var showSecondaryDetails = b && !(0, _flashAlertUtils.isLoadingChunkError)(b);
+      return /*#__PURE__*/_react.default.createElement(_uiText.Text, {
+        as: "p",
+        fontStyle: "italic"
+      }, showPrimaryDetails && /*#__PURE__*/_react.default.createElement(_uiText.Text, null, a), showSecondaryDetails && /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement("br", null), /*#__PURE__*/_react.default.createElement(_uiText.Text, null, b)));
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var details = null;
+
+      if (this.props.error) {
+        var _findDetailMessage = (0, _flashAlertUtils.findDetailMessage)(this.props.error),
+            a = _findDetailMessage.a,
+            b = _findDetailMessage.b;
+
+        var showPrimaryDetails = a && !(0, _flashAlertUtils.isLoadingChunkError)(a);
+        var showSecondaryDetails = b && !(0, _flashAlertUtils.isLoadingChunkError)(b);
+
+        if (showPrimaryDetails || showSecondaryDetails) {
+          if (this.state.showDetails) {
+            details = this.renderDetailMessage(a, b);
+          } else {
+            details = /*#__PURE__*/_react.default.createElement("span", null, /*#__PURE__*/_react.default.createElement(_uiA11yContent.PresentationContent, null, /*#__PURE__*/_react.default.createElement(_uiLink.Link, {
+              isWithinText: false,
+              as: "button",
+              onClick: this.showDetails
+            }, "D\xE9tails")), /*#__PURE__*/_react.default.createElement(_uiA11yContent.ScreenReaderContent, null, this.renderDetailMessage(a, b)));
+          }
+        }
+      }
+
+      return /*#__PURE__*/_react.default.createElement(_uiMotion.Transition, {
+        transitionOnMount: true,
+        in: this.state.isOpen,
+        type: "fade"
+      }, /*#__PURE__*/_react.default.createElement(_uiAlerts.Alert, {
+        variant: this.props.variant,
+        renderCloseButtonLabel: "Fermer",
+        onDismiss: this.closeAlert,
+        margin: "small auto",
+        timeout: this.props.timeout,
+        liveRegion: this.getLiveRegion,
+        transition: "fade",
+        screenReaderOnly: this.props.screenReaderOnly
+      }, /*#__PURE__*/_react.default.createElement("div", null, /*#__PURE__*/_react.default.createElement("p", {
+        style: {
+          margin: '0 -5px'
+        }
+      }, this.props.message), details)));
+    }
+  }]);
+  FlashAlert.displayName = "FlashAlert";
+  return FlashAlert;
+}(_react.default.Component);
+
+FlashAlert.propTypes = {
+  onClose: _propTypes.default.func.isRequired,
+  message: _propTypes.default.string.isRequired,
+  error: _propTypes.default.instanceOf(Error),
+  variant: _propTypes.default.oneOf(['info', 'success', 'warning', 'error']),
+  timeout: _propTypes.default.number,
+  screenReaderOnly: _propTypes.default.bool
+};
+FlashAlert.defaultProps = {
+  error: null,
+  variant: 'info',
+  timeout: defaultTimeout,
+  screenReaderOnly: false
+};
+var _default = FlashAlert;
+exports.default = _default;