@atlaskit/link-datasource 0.14.4

package/dist/esm/hooks/useDatasourceTableState.js

@@ -0,0 +1,125 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { useCallback, useEffect, useState } from 'react';
+import { useDatasourceClientExtension } from '@atlaskit/link-client-extension';
+export var useDatasourceTableState = function useDatasourceTableState(datasourceId, parameters, fields) {
+  var _useState = useState([]),
+    _useState2 = _slicedToArray(_useState, 2),
+    defaultVisibleColumnKeys = _useState2[0],
+    setDefaultVisibleColumnKeys = _useState2[1];
+  var _useState3 = useState('empty'),
+    _useState4 = _slicedToArray(_useState3, 2),
+    status = _useState4[0],
+    setStatus = _useState4[1];
+  var _useState5 = useState([]),
+    _useState6 = _slicedToArray(_useState5, 2),
+    responseItems = _useState6[0],
+    setResponseItems = _useState6[1];
+  var _useState7 = useState(true),
+    _useState8 = _slicedToArray(_useState7, 2),
+    hasNextPage = _useState8[0],
+    setHasNextPage = _useState8[1];
+  var _useState9 = useState(undefined),
+    _useState10 = _slicedToArray(_useState9, 2),
+    nextCursor = _useState10[0],
+    setNextCursor = _useState10[1];
+  var _useState11 = useState([]),
+    _useState12 = _slicedToArray(_useState11, 2),
+    columns = _useState12[0],
+    setColumns = _useState12[1];
+  var _useState13 = useState(undefined),
+    _useState14 = _slicedToArray(_useState13, 2),
+    totalIssueCount = _useState14[0],
+    setTotalIssueCount = _useState14[1];
+  var _useDatasourceClientE = useDatasourceClientExtension(),
+    getDatasourceData = _useDatasourceClientE.getDatasourceData,
+    getDatasourceDetails = _useDatasourceClientE.getDatasourceDetails;
+  var loadDatasourceDetails = useCallback( /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref) {
+      var _getDatasourceDetails;
+      var cloudId, parameterValue, parameterType, result;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            cloudId = _ref.cloudId, parameterValue = _ref.value, parameterType = _ref.type;
+            _context.next = 3;
+            return getDatasourceDetails(datasourceId, (_getDatasourceDetails = {}, _defineProperty(_getDatasourceDetails, parameterType, parameterValue), _defineProperty(_getDatasourceDetails, "cloudId", cloudId), _getDatasourceDetails));
+          case 3:
+            result = _context.sent;
+            setColumns(result.schema.properties);
+            setDefaultVisibleColumnKeys(result.schema.defaultProperties);
+          case 6:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return function (_x) {
+      return _ref2.apply(this, arguments);
+    };
+  }(), [datasourceId, getDatasourceDetails]);
+  useEffect(function () {
+    if (parameters) {
+      void loadDatasourceDetails(parameters);
+    }
+  }, [loadDatasourceDetails, parameters]);
+  var onNextPage = useCallback( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var cloudId, parameterValue, parameterType, _yield$getDatasourceD, data, nextPageCursor, totalIssues;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          if (parameters) {
+            _context2.next = 2;
+            break;
+          }
+          return _context2.abrupt("return");
+        case 2:
+          cloudId = parameters.cloudId, parameterValue = parameters.value, parameterType = parameters.type;
+          setStatus('loading');
+          _context2.next = 6;
+          return getDatasourceData(datasourceId, {
+            parameters: _defineProperty({
+              cloudId: cloudId
+            }, parameterType, parameterValue),
+            pageSize: 10,
+            pageCursor: nextCursor,
+            fields: fields
+          });
+        case 6:
+          _yield$getDatasourceD = _context2.sent;
+          data = _yield$getDatasourceD.data;
+          nextPageCursor = _yield$getDatasourceD.nextPageCursor;
+          totalIssues = _yield$getDatasourceD.totalIssues;
+          setTotalIssueCount(totalIssues);
+          setNextCursor(nextPageCursor);
+          setResponseItems(function (currentResponseItems) {
+            return [].concat(_toConsumableArray(currentResponseItems), _toConsumableArray(data));
+          });
+          setStatus('resolved');
+          setHasNextPage(Boolean(nextPageCursor));
+        case 15:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })), [parameters, getDatasourceData, datasourceId, nextCursor, fields]);
+  var reset = useCallback(function () {
+    setStatus('empty');
+    setResponseItems([]);
+    setHasNextPage(true);
+    setTotalIssueCount(undefined);
+  }, []);
+  return {
+    status: status,
+    onNextPage: onNextPage,
+    responseItems: responseItems,
+    reset: reset,
+    hasNextPage: hasNextPage,
+    columns: columns,
+    defaultVisibleColumnKeys: defaultVisibleColumnKeys,
+    totalIssueCount: totalIssueCount
+  };
+};

package/dist/esm/index.js

@@ -0,0 +1,2 @@
+export { JiraIssuesConfigModal } from './ui/jira-issues/modal';
+export { JiraIssuesTableView } from './ui/jira-issues/tableView';

package/dist/esm/services/getAvailableJiraSites.js

@@ -0,0 +1,57 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+export var getAvailableJiraSites = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var requestConfig, response, res;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          requestConfig = {
+            method: 'POST',
+            credentials: 'include',
+            headers: {
+              Accept: 'application/json',
+              'Cache-Control': 'no-cache',
+              'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+              products: ['jira-software.ondemand', 'jira-core.ondemand', 'jira-incident-manager.ondemand', 'jira-product-discovery', 'jira-servicedesk.ondemand']
+            })
+          };
+          _context.next = 3;
+          return fetch("/gateway/api/available-sites", requestConfig);
+        case 3:
+          response = _context.sent;
+          if (!response.ok) {
+            _context.next = 9;
+            break;
+          }
+          _context.next = 7;
+          return response.json();
+        case 7:
+          res = _context.sent;
+          return _context.abrupt("return", res.sites);
+        case 9:
+          _context.t0 = Error;
+          _context.next = 12;
+          return response.text();
+        case 12:
+          _context.t1 = _context.sent;
+          if (_context.t1) {
+            _context.next = 15;
+            break;
+          }
+          _context.t1 = 'Something went wrong';
+        case 15:
+          _context.t2 = _context.t1;
+          throw new _context.t0(_context.t2);
+        case 17:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function getAvailableJiraSites() {
+    return _ref.apply(this, arguments);
+  };
+}();

package/dist/esm/services/makeGetJqlAutocompleteData.js

@@ -0,0 +1,58 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+export var makeGetJqlAutocompleteData = function makeGetJqlAutocompleteData(cloudId) {
+  return /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(url) {
+      var response, data;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return fetch("/gateway/api/ex/jira/".concat(cloudId, "/").concat(url), {
+              method: 'POST',
+              headers: {
+                'content-type': 'application/json'
+              },
+              body: JSON.stringify({
+                includeCollapsedFields: true
+              })
+            });
+          case 2:
+            response = _context.sent;
+            if (!response.ok) {
+              _context.next = 8;
+              break;
+            }
+            _context.next = 6;
+            return response.json();
+          case 6:
+            data = _context.sent;
+            return _context.abrupt("return", {
+              jqlFields: data.visibleFieldNames,
+              jqlFunctions: data.visibleFunctionNames
+            });
+          case 8:
+            _context.t0 = Error;
+            _context.next = 11;
+            return response.text();
+          case 11:
+            _context.t1 = _context.sent;
+            if (_context.t1) {
+              _context.next = 14;
+              break;
+            }
+            _context.t1 = 'Something went wrong';
+          case 14:
+            _context.t2 = _context.t1;
+            throw new _context.t0(_context.t2);
+          case 16:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return function (_x) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+};

package/dist/esm/services/makeGetJqlSuggestionsData.js

@@ -0,0 +1,47 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+export var makeGetJqlSuggestionsData = function makeGetJqlSuggestionsData(cloudId) {
+  return /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(url) {
+      var response;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return fetch("/gateway/api/ex/jira/".concat(cloudId, "/").concat(url), {
+              headers: {
+                'content-type': 'application/json'
+              }
+            });
+          case 2:
+            response = _context.sent;
+            if (!response.ok) {
+              _context.next = 5;
+              break;
+            }
+            return _context.abrupt("return", response.json());
+          case 5:
+            _context.t0 = Error;
+            _context.next = 8;
+            return response.text();
+          case 8:
+            _context.t1 = _context.sent;
+            if (_context.t1) {
+              _context.next = 11;
+              break;
+            }
+            _context.t1 = 'Something went wrong';
+          case 11:
+            _context.t2 = _context.t1;
+            throw new _context.t0(_context.t2);
+          case 13:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return function (_x) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+};

package/dist/esm/ui/issue-like-table/column-picker/index.js

@@ -0,0 +1,85 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+var _excluded = ["isOpen"];
+/** @jsx jsx */
+import { useCallback, useMemo } from 'react';
+import { jsx } from '@emotion/react';
+import Button from '@atlaskit/button/standard-button';
+import BoardIcon from '@atlaskit/icon/glyph/board';
+import ChevronDownIcon from '@atlaskit/icon/glyph/chevron-down';
+import { CheckboxOption, PopupSelect } from '@atlaskit/select';
+export var ColumnPicker = function ColumnPicker(_ref) {
+  var columns = _ref.columns,
+    selectedColumnKeys = _ref.selectedColumnKeys,
+    onSelectedColumnKeysChange = _ref.onSelectedColumnKeysChange;
+  var mapColumnToOption = useCallback(function (_ref2) {
+    var key = _ref2.key,
+      title = _ref2.title;
+    return {
+      label: title,
+      value: key
+    };
+  }, []);
+  var selectedOptions = columns.filter(function (_ref3) {
+    var key = _ref3.key;
+    return selectedColumnKeys.includes(key);
+  }).map(mapColumnToOption);
+  var allOptions = useMemo(function () {
+    return columns.filter(function (_ref4) {
+      var title = _ref4.title,
+        key = _ref4.key;
+      return title;
+    }).map(mapColumnToOption);
+  }, [columns, mapColumnToOption]);
+  var handleChange = useCallback(function (selectedOptions) {
+    var selectedValues = selectedOptions.map(function (_ref5) {
+      var value = _ref5.value;
+      return value;
+    });
+    selectedValues.sort(function (a, b) {
+      var indexB = columns.findIndex(function (_ref6) {
+        var key = _ref6.key;
+        return key === b;
+      });
+      var indexA = columns.findIndex(function (_ref7) {
+        var key = _ref7.key;
+        return key === a;
+      });
+      return indexA - indexB;
+    });
+    onSelectedColumnKeysChange(selectedValues);
+  }, [columns, onSelectedColumnKeysChange]);
+  return jsx(PopupSelect, {
+    classNamePrefix: 'column-picker-popup',
+    testId: 'column-picker-popup',
+    components: {
+      Option: CheckboxOption
+    },
+    options: allOptions,
+    value: selectedOptions,
+    closeMenuOnSelect: false,
+    hideSelectedOptions: false,
+    isMulti: true,
+    placeholder: "Search for fields" // TODO Translate
+    ,
+    "aria-label": "Search for fields",
+    onChange: handleChange,
+    target: function target(_ref8) {
+      var isOpen = _ref8.isOpen,
+        triggerProps = _objectWithoutProperties(_ref8, _excluded);
+      return jsx(Button, _extends({}, triggerProps, {
+        isSelected: isOpen,
+        iconBefore: jsx("div", null, jsx(BoardIcon, {
+          label: "board",
+          size: "small"
+        }), jsx(ChevronDownIcon, {
+          label: "down",
+          size: "small"
+        })),
+        spacing: "compact",
+        appearance: "subtle",
+        testId: "column-picker-trigger-button"
+      }));
+    }
+  });
+};

package/dist/esm/ui/issue-like-table/column-picker/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/ui/issue-like-table/draggable-table-heading.js

@@ -0,0 +1,173 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+/** @jsx jsx */
+import { useEffect, useRef, useState } from 'react';
+import { css, jsx } from '@emotion/react';
+import invariant from 'tiny-invariant';
+import DragHandlerIcon from '@atlaskit/icon/glyph/drag-handler';
+import { attachClosestEdge, extractClosestEdge } from '@atlaskit/pragmatic-drag-and-drop-hitbox/addon/closest-edge';
+import { DropIndicator } from '@atlaskit/pragmatic-drag-and-drop-react-indicator/box';
+import { draggable, dropTargetForElements, monitorForElements } from '@atlaskit/pragmatic-drag-and-drop/adapter/element';
+import { combine } from '@atlaskit/pragmatic-drag-and-drop/util/combine';
+import { TableHeading } from './styled';
+var tableHeadingStyles = css({
+  cursor: 'grab'
+});
+var tableHeadingStatusStyles = {
+  idle: css({
+    ':hover': {
+      background: "var(--ds-surface-hovered, #091E4224)"
+    }
+  }),
+  dragging: css({
+    background: "var(--ds-background-disabled, #091E4224)",
+    color: "var(--ds-text-disabled, #091E424F)"
+  })
+};
+var verticallyAlignedStyles = css({
+  display: 'flex',
+  alignItems: 'center',
+  whiteSpace: 'nowrap'
+});
+var dragHandleStyles = css({
+  position: 'relative',
+  display: 'flex',
+  alignItems: 'center'
+});
+var dropTargetStyles = css({
+  position: 'absolute',
+  top: 0,
+  left: 0,
+  width: '100%'
+});
+var noPointerEventsStyles = css({
+  pointerEvents: 'none'
+});
+export var DraggableTableHeading = function DraggableTableHeading(_ref) {
+  var children = _ref.children,
+    id = _ref.id,
+    index = _ref.index,
+    tableId = _ref.tableId,
+    dndPreviewHeight = _ref.dndPreviewHeight,
+    onDragPreviewStart = _ref.onDragPreviewStart,
+    onDragPreviewEnd = _ref.onDragPreviewEnd;
+  var ref = useRef(null);
+  var _useState = useState('idle'),
+    _useState2 = _slicedToArray(_useState, 2),
+    status = _useState2[0],
+    setStatus = _useState2[1];
+  var _useState3 = useState(false),
+    _useState4 = _slicedToArray(_useState3, 2),
+    isDraggingAnyColumn = _useState4[0],
+    setIsDraggingAnyColumn = _useState4[1];
+  var _useState5 = useState(null),
+    _useState6 = _slicedToArray(_useState5, 2),
+    closestEdge = _useState6[0],
+    setClosestEdge = _useState6[1];
+  var dropTargetRef = useRef(null);
+  useEffect(function () {
+    var cell = ref.current;
+    invariant(cell);
+    return combine(draggable({
+      element: cell,
+      getInitialData: function getInitialData() {
+        return {
+          type: 'table-header',
+          id: id,
+          index: index,
+          tableId: tableId
+        };
+      },
+      onGenerateDragPreview: function onGenerateDragPreview() {
+        setStatus('preview');
+        onDragPreviewStart();
+      },
+      onDragStart: function onDragStart() {
+        setStatus('dragging');
+        onDragPreviewEnd();
+      },
+      onDrop: function onDrop() {
+        setStatus('idle');
+      }
+    }));
+  }, [id, index, onDragPreviewEnd, onDragPreviewStart, tableId]);
+
+  // Here we handle drop target, that in our case is absolutely positioned div that covers full width and height
+  // of this column (has height of whole table). It sits on top of everything, but has `pointerEvents: 'none'` by default
+  useEffect(function () {
+    var dropTarget = dropTargetRef.current;
+    invariant(dropTarget);
+    return dropTargetForElements({
+      element: dropTarget,
+      getIsSticky: function getIsSticky() {
+        return true;
+      },
+      getData: function getData(_ref2) {
+        var input = _ref2.input,
+          element = _ref2.element;
+        var data = {
+          id: id,
+          index: index
+        };
+        return attachClosestEdge(data, {
+          input: input,
+          element: element,
+          allowedEdges: ['left', 'right']
+        });
+      },
+      canDrop: function canDrop(args) {
+        return args.source.data.type === 'table-header' && args.source.data.tableId === tableId;
+      },
+      onDrag: function onDrag(args) {
+        if (args.source.data.id !== id) {
+          setClosestEdge(extractClosestEdge(args.self.data));
+        }
+      },
+      onDragLeave: function onDragLeave() {
+        setClosestEdge(null);
+      },
+      onDrop: function onDrop() {
+        setClosestEdge(null);
+      }
+    });
+  }, [id, index, tableId]);
+
+  // During dragging anywhere we want to remove `pointerEvents: 'none'` from all the drop targets
+  useEffect(function () {
+    return monitorForElements({
+      canMonitor: function canMonitor(_ref3) {
+        var source = _ref3.source;
+        return source.data.type === 'table-header' && source.data.tableId === tableId;
+      },
+      onDragStart: function onDragStart() {
+        /**
+         * Should cause a synchronous re-render.
+         */
+        setIsDraggingAnyColumn(true);
+      },
+      onDrop: function onDrop() {
+        setIsDraggingAnyColumn(false);
+      }
+    });
+  }, [tableId]);
+  return jsx(TableHeading, {
+    ref: ref,
+    css: [tableHeadingStyles, tableHeadingStatusStyles[status]],
+    "data-testid": "".concat(id, "-column-heading")
+  }, jsx("div", {
+    ref: dropTargetRef,
+    css: [dropTargetStyles, isDraggingAnyColumn ? null : noPointerEventsStyles],
+    style: {
+      height: "".concat(dndPreviewHeight, "px")
+    },
+    "data-testid": 'column-drop-target'
+  }, closestEdge && jsx(DropIndicator, {
+    edge: closestEdge
+  })), jsx("div", {
+    css: verticallyAlignedStyles
+  }, jsx("div", {
+    css: dragHandleStyles
+  }, jsx(DragHandlerIcon, {
+    label: "".concat(id, "-drag-icon"),
+    size: "medium"
+  })), children));
+};

package/dist/esm/ui/issue-like-table/empty-state/index.js

@@ -0,0 +1,118 @@
+/** @jsx jsx */
+import { useCallback } from 'react';
+import { jsx } from '@emotion/react';
+import { Skeleton } from '@atlaskit/linking-common';
+import UserType from '../render-type/user';
+import { TableHeading } from '../styled';
+import Priority from './priority';
+import Type from './type';
+var columns = [{
+  key: 'type',
+  title: 'Type'
+}, {
+  key: 'issue',
+  title: 'Key',
+  width: 50
+}, {
+  key: 'summary',
+  title: 'Summary'
+}, {
+  key: 'assignee',
+  title: 'Assignee',
+  width: 100
+}, {
+  key: 'priority',
+  title: 'P'
+}, {
+  key: 'status',
+  title: 'Status'
+}, {
+  key: 'resolution',
+  title: 'Resolution'
+}, {
+  key: 'created',
+  title: 'Created'
+}, {
+  key: 'due',
+  title: 'Updated'
+}];
+var priorities = ['low', 'medium', 'high', 'medium', 'low', 'blocker', 'medium', 'blocker', 'high', 'low'];
+var types = ['task', 'story', 'commit', 'epic', 'bug', 'task', 'story', 'commit', 'issue', 'epic'];
+var summaryColumnWidths = [141, 208, 186, 212, 212, 151, 212, 182, 180, 147];
+var statusColumnWidths = [75, 54, 66, 73, 52, 73, 55, 80, 66, 59];
+var rows = new Array(10).fill(null).map(function (_, index) {
+  return {
+    id: index,
+    priority: priorities[index],
+    type: types[index],
+    summaryWidth: summaryColumnWidths[index],
+    statusWidth: statusColumnWidths[index]
+  };
+});
+export default (function (props) {
+  var renderItem = useCallback(function (_ref, _ref2) {
+    var key = _ref.key,
+      width = _ref.width;
+    var priority = _ref2.priority,
+      type = _ref2.type,
+      summaryWidth = _ref2.summaryWidth,
+      statusWidth = _ref2.statusWidth;
+    switch (key) {
+      case 'assignee':
+        return jsx(UserType, null, jsx(Skeleton, {
+          width: width,
+          height: 13,
+          borderRadius: 8
+        }));
+      case 'priority':
+        return jsx(Priority, {
+          priority: priority
+        });
+      case 'type':
+        return jsx(Type, {
+          type: type
+        });
+      case 'summary':
+        return jsx(Skeleton, {
+          appearance: "blue",
+          width: summaryWidth,
+          borderRadius: 10,
+          height: 13
+        });
+      case 'status':
+        return jsx(Skeleton, {
+          appearance: "blue",
+          width: statusWidth,
+          height: 16,
+          borderRadius: 3
+        });
+      default:
+        return jsx(Skeleton, {
+          width: width,
+          height: 13,
+          borderRadius: 8
+        });
+    }
+  }, []);
+  return jsx("table", {
+    "data-testid": props.testId
+  }, jsx("thead", null, jsx("tr", null, columns.map(function (_ref3) {
+    var title = _ref3.title,
+      key = _ref3.key,
+      width = _ref3.width;
+    return jsx(TableHeading, {
+      key: key,
+      style: {
+        width: width
+      }
+    }, title);
+  }))), jsx("tbody", null, rows.map(function (row) {
+    return jsx("tr", {
+      key: row.id
+    }, columns.map(function (column) {
+      return jsx("td", {
+        key: column.key
+      }, renderItem(column, row));
+    }));
+  })));
+});

package/dist/esm/ui/issue-like-table/empty-state/priority.js

@@ -0,0 +1,20 @@
+import React from 'react';
+import { B300, R300, Y300 } from '@atlaskit/theme/colors';
+import IconType from '../render-type/icon';
+// https://stackoverflow.com/questions/61099149/svg-fill-color-not-working-with-hex-colors
+var replaceHashInHex = function replaceHashInHex(hex) {
+  return hex.replace('#', '%23');
+};
+var priorityToSVGPathMap = {
+  low: " <path\n  d=\"M12.5 6.1c.5-.3 1.1-.1 1.4.4.3.5.1 1.1-.3 1.3l-5 3c-.3.2-.7.2-1 0l-5-3c-.6-.2-.7-.9-.4-1.3.2-.5.9-.7 1.3-.4L8 8.8l4.5-2.7z\"\n  fill=\"".concat(replaceHashInHex(B300), "\"\n/>"),
+  medium: "<path\n  fill=\"".concat(replaceHashInHex(Y300), "\"\n  d=\"M3,4h10c0.6,0,1,0.4,1,1s-0.4,1-1,1H3C2.4,6,2,5.6,2,5S2.4,4,3,4z M3,10h10c0.6,0,1,0.4,1,1s-0.4,1-1,1H3\n c-0.6,0-1-0.4-1-1S2.4,10,3,10z\"\n/>"),
+  high: "<path\n  d=\"M3.5 9.9c-.5.3-1.1.1-1.4-.3s-.1-1.1.4-1.4l5-3c.3-.2.7-.2 1 0l5 3c.5.3.6.9.3 1.4-.3.5-.9.6-1.4.3L8 7.2 3.5 9.9z\"\n  fill=\"".concat(replaceHashInHex(R300), "\"\n/>"),
+  blocker: "<path\n  d=\"M8 15c-3.9 0-7-3.1-7-7s3.1-7 7-7 7 3.1 7 7-3.1 7-7 7zM4 7c-.6 0-1 .4-1 1s.4 1 1 1h8c.6 0 1-.4 1-1s-.4-1-1-1H4z\"\n  fill=\"".concat(replaceHashInHex(R300), "\"\n/>")
+};
+export default (function (_ref) {
+  var priority = _ref.priority;
+  var image = "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\">".concat(priorityToSVGPathMap[priority], "</svg>");
+  return /*#__PURE__*/React.createElement(IconType, {
+    source: "data:image/svg+xml;utf8,".concat(image)
+  });
+});