@atlaskit/link-datasource 1.11.1 → 1.12.1

package/dist/es2019/services/useBasicFilterAGG.js

@@ -0,0 +1,72 @@
+import { useCallback, useMemo } from 'react';
+import { useSmartLinkContext } from '@atlaskit/link-provider';
+import { getBaseUrl } from '@atlaskit/linking-common';
+import { fieldValuesQuery, hydrateJQLQuery } from './utils';
+const getGraphqlUrl = (envKey, baseUrlOverride) => {
+  const baseUrl = baseUrlOverride || getBaseUrl(envKey);
+  return baseUrl ? `${baseUrl}/graphql` : '/gateway/api/graphql';
+};
+export const useBasicFilterAGG = () => {
+  const {
+    connections: {
+      client
+    }
+  } = useSmartLinkContext();
+  const gatewayGraphqlUrl = getGraphqlUrl(client.envKey, client.baseUrlOverride);
+  const aggHeaders = useMemo(() => {
+    return new Headers({
+      'Content-Type': 'application/json',
+      'X-ExperimentalApi': 'JiraJqlBuilder'
+    });
+  }, []);
+  const getHydratedJQL = useCallback(async (cloudId, jql) => {
+    const body = JSON.stringify({
+      variables: {
+        cloudId,
+        jql
+      },
+      operationName: 'hydrate',
+      query: hydrateJQLQuery
+    });
+    const request = new Request(gatewayGraphqlUrl, {
+      method: 'POST',
+      headers: aggHeaders,
+      body
+    });
+    try {
+      const response = await fetch(request);
+      return response.json();
+    } catch (e) {
+      throw new Error(e);
+    }
+  }, [gatewayGraphqlUrl, aggHeaders]);
+  const getFieldValues = useCallback(async (cloudId, jql, jqlTerm, searchString, pageCursor) => {
+    const body = JSON.stringify({
+      variables: {
+        cloudId,
+        jql,
+        first: 10,
+        jqlTerm,
+        searchString,
+        after: pageCursor
+      },
+      operationName: 'fieldValues',
+      query: fieldValuesQuery
+    });
+    const request = new Request(gatewayGraphqlUrl, {
+      method: 'POST',
+      headers: aggHeaders,
+      body
+    });
+    try {
+      const response = await fetch(request);
+      return await response.json();
+    } catch (e) {
+      throw new Error(e);
+    }
+  }, [gatewayGraphqlUrl, aggHeaders]);
+  return useMemo(() => ({
+    getHydratedJQL,
+    getFieldValues
+  }), [getHydratedJQL, getFieldValues]);
+};

package/dist/es2019/services/utils.js

@@ -0,0 +1,113 @@
+export const hydrateJQLQuery = `query hydrate($cloudId: ID!, $jql: String!) {
+  jira {
+    jqlBuilder(cloudId: $cloudId) {
+      hydrateJqlQuery(query: $jql) {
+        ... on JiraJqlHydratedQuery {
+          fields {
+            ... on JiraJqlQueryHydratedField {
+              jqlTerm
+              values {
+                ... on JiraJqlQueryHydratedValue {
+                  values {
+                    ... on JiraJqlProjectFieldValue {
+                      jqlTerm
+                      displayName
+                      project {
+                        avatar {
+                          small
+                        }
+                      }
+                    }
+                    ... on JiraJqlStatusFieldValue {
+                      jqlTerm
+                      displayName
+                      statusCategory {
+                        colorName
+                      }
+                    }
+                    ... on JiraJqlIssueTypeFieldValue {
+                      jqlTerm
+                      displayName
+                      issueTypes {
+                        avatar {
+                          small
+                        }
+                      }
+                    }
+                    ... on JiraJqlUserFieldValue {
+                      jqlTerm
+                      displayName
+                      user {
+                        picture
+                      }
+                    }
+                    ... on JiraJqlGroupFieldValue {
+                      jqlTerm
+                      displayName
+                      group {
+                        name
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}`;
+export const fieldValuesQuery = `query fieldValues($cloudId: ID!, $first: Int = 10, $jqlTerm: String!, $jql: String!, $searchString: String!, $after: String, $projectOptions: JiraProjectOptions) {
+  jira {
+    jqlBuilder(cloudId: $cloudId) {
+      fieldValues(
+        first: $first
+        jqlTerm: $jqlTerm
+        jqlContext: $jql
+        searchString: $searchString
+        after: $after
+      ) {
+        totalCount
+        pageInfo {
+          endCursor
+        }
+        edges {
+          node {
+            jqlTerm
+            displayName
+            ... on JiraJqlProjectFieldValue {
+              project {
+                avatar {
+                  small
+                }
+              }
+            }
+            ... on JiraJqlIssueTypeFieldValue {
+              issueTypes {
+                avatar {
+                  small
+                }
+              }
+            }
+            ... on JiraJqlStatusFieldValue {
+              statusCategory {
+                colorName
+              }
+            }
+            ... on JiraJqlUserFieldValue {
+              user {
+                picture
+              }
+            }
+            ... on JiraJqlGroupFieldValue {
+              group {
+                name
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}`;

package/dist/es2019/ui/assets-modal/modal/index.js

@@ -216,7 +216,7 @@ const PlainAssetsConfigModal = props => {
     onCancel();
   }, [analyticsPayload, onCancel]);
   const handleOnSearch = useCallback(async (searchAql, searchSchemaId) => {
-    if (schemaId !== searchSchemaId || aql !== searchAql) {
+    if (schemaId !== searchSchemaId || aql !== searchAql || status === 'rejected') {
       searchCount.current++;
       if (schemaId !== searchSchemaId) {
         userInteractionActions.current.add(DatasourceAction.SCHEMA_UPDATED);
@@ -231,7 +231,7 @@ const PlainAssetsConfigModal = props => {
       setSchemaId(searchSchemaId);
       setIsNewSearch(true);
     }
-  }, [aql, reset, schemaId]);
+  }, [aql, reset, schemaId, status]);
   const renderModalTitleContent = useCallback(() => {
     if (workspaceError) {
       return undefined;

package/dist/es2019/ui/datasource-table-view/datasourceTableView.js

@@ -21,7 +21,9 @@ const DatasourceTableViewWithoutAnalytics = ({
   parameters,
   visibleColumnKeys,
   onVisibleColumnKeysChange,
-  url
+  url,
+  columnCustomSizes,
+  onColumnResize
 }) => {
   const {
     reset,
@@ -132,6 +134,8 @@ const DatasourceTableViewWithoutAnalytics = ({
       columns: columns,
       visibleColumnKeys: visibleColumnKeys || defaultVisibleColumnKeys,
       onVisibleColumnKeysChange: onVisibleColumnKeysChange,
+      columnCustomSizes: columnCustomSizes,
+      onColumnResize: onColumnResize,
       scrollableContainerHeight: ScrollableContainerHeight,
       parentContainerRenderInstanceId: tableRenderInstanceId,
       extensionKey: extensionKey

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

@@ -6,10 +6,13 @@ import invariant from 'tiny-invariant';
 import { attachClosestEdge, extractClosestEdge } from '@atlaskit/pragmatic-drag-and-drop-hitbox/addon/closest-edge';
 import { DropIndicator } from '@atlaskit/pragmatic-drag-and-drop-react-indicator/box-without-terminal';
 import { draggable, dropTargetForElements, monitorForElements } from '@atlaskit/pragmatic-drag-and-drop/adapter/element';
+import { cancelUnhandled } from '@atlaskit/pragmatic-drag-and-drop/addon/cancel-unhandled';
 import { combine } from '@atlaskit/pragmatic-drag-and-drop/util/combine';
+import { disableNativeDragPreview } from '@atlaskit/pragmatic-drag-and-drop/util/disable-native-drag-preview';
 import { offsetFromPointer } from '@atlaskit/pragmatic-drag-and-drop/util/offset-from-pointer';
 import { setCustomNativeDragPreview } from '@atlaskit/pragmatic-drag-and-drop/util/set-custom-native-drag-preview';
 import { TableHeading } from './styled';
+import { COLUMN_MIN_WIDTH } from './index';
 const tableHeadingStatusStyles = {
   idle: css({
     ':hover': {
@@ -35,6 +38,40 @@ const dropTargetStyles = css({
 const noPointerEventsStyles = css({
   pointerEvents: 'none'
 });
+const resizerStyles = css({
+  '--local-hitbox-width': "var(--ds-space-300, 24px)",
+  width: 'var(--local-hitbox-width)',
+  cursor: 'col-resize',
+  flexGrow: '0',
+  position: 'absolute',
+  zIndex: 1,
+  // we want this to sit on top of adjacent column headers
+  right: 'calc(-1 * calc(var(--local-hitbox-width) / 2))',
+  top: 0,
+  '::before': {
+    opacity: 0,
+    '--local-line-width': "var(--ds-border-width, 2px)",
+    content: '""',
+    position: 'absolute',
+    background: "var(--ds-border-brand, #0052CC)",
+    width: 'var(--local-line-width)',
+    inset: 0,
+    left: `calc(50% - calc(var(--local-line-width) / 2))`,
+    transition: 'opacity 0.2s ease'
+  },
+  ':hover::before': {
+    opacity: 1
+  }
+});
+const resizingStyles = css({
+  // turning off the resizing cursor as sometimes it can cause the cursor to flicker
+  // while resizing. The browser controls the cursor while dragging, but the browser
+  // can sometimes bug out.
+  cursor: 'unset',
+  '::before': {
+    opacity: 1
+  }
+});
 const idleState = {
   type: 'idle'
 };
@@ -48,15 +85,17 @@ export const DraggableTableHeading = ({
   tableId,
   dndPreviewHeight,
   dragPreview,
-  maxWidth
+  width,
+  onWidthChange
 }) => {
-  const ref = useRef(null);
+  const mainHeaderCellRef = useRef(null);
+  const columnResizeHandleRef = useRef(null);
   const [state, setState] = useState(idleState);
   const [isDraggingAnyColumn, setIsDraggingAnyColumn] = useState(false);
   const [closestEdge, setClosestEdge] = useState(null);
   const dropTargetRef = useRef(null);
   useEffect(() => {
-    const cell = ref.current;
+    const cell = mainHeaderCellRef.current;
     invariant(cell);
     return combine(draggable({
       element: cell,
@@ -161,15 +200,84 @@ export const DraggableTableHeading = ({
       }
     });
   }, [tableId]);
+
+  // Handling column resizing
+  useEffect(() => {
+    const resizeHandle = columnResizeHandleRef.current;
+    invariant(resizeHandle);
+    const mainHeaderCell = mainHeaderCellRef.current;
+    invariant(mainHeaderCell);
+    return draggable({
+      element: resizeHandle,
+      getInitialData() {
+        // metadata related to currently dragging item (can be read by drop events etc)
+        return {
+          type: 'column-resize',
+          id,
+          index,
+          tableId
+        };
+      },
+      // Is called when dragging started
+      onGenerateDragPreview({
+        nativeSetDragImage
+      }) {
+        // We don't show any preview, since column separator (handle) is moving with the cursor
+        disableNativeDragPreview({
+          nativeSetDragImage
+        });
+        // Block drag operations outside `@atlaskit/pragmatic-drag-and-drop`
+        cancelUnhandled.start();
+        setState({
+          type: 'resizing',
+          initialWidth: width
+        });
+      },
+      onDrag({
+        location
+      }) {
+        const relativeDistanceX = location.current.input.clientX - location.initial.input.clientX;
+        invariant(state.type === 'resizing');
+        const {
+          initialWidth
+        } = state;
+
+        // Set the width of our header being resized
+        let proposedWidth = initialWidth + relativeDistanceX;
+        if (initialWidth >= COLUMN_MIN_WIDTH && proposedWidth < COLUMN_MIN_WIDTH) {
+          proposedWidth = COLUMN_MIN_WIDTH;
+        }
+
+        // We update width css directly live
+        mainHeaderCell.style.setProperty('width', `${proposedWidth}px`);
+      },
+      onDrop() {
+        cancelUnhandled.stop();
+        setState(idleState);
+        if (onWidthChange) {
+          // We use element's css value as a source of truth (compare to another Ref)
+          const currentWidthPx = mainHeaderCell.style.getPropertyValue('width');
+          onWidthChange(+currentWidthPx.slice(0, -2));
+        }
+      }
+    });
+  }, [id, index, onWidthChange, state, tableId, width]);
   return jsx(TableHeading, {
-    ref: ref,
+    ref: mainHeaderCellRef,
     css: [tableHeadingStatusStyles[state.type]],
     "data-testid": `${id}-column-heading`,
     style: {
-      maxWidth,
+      width,
       cursor: 'grab'
     }
   }, jsx("div", {
+    ref: columnResizeHandleRef,
+    css: [resizerStyles, state.type === 'resizing' && resizingStyles],
+    style: {
+      height: `${dndPreviewHeight}px`
+    },
+    "data-testid": "column-resize-handle"
+  }), jsx("div", {
     ref: dropTargetRef,
     css: [dropTargetStyles, isDraggingAnyColumn ? null : noPointerEventsStyles],
     style: {

package/dist/es2019/ui/issue-like-table/index.js

@@ -29,7 +29,8 @@ const tableHeadStyles = css({
   zIndex: stickyTableHeadersIndex
 });
 const ColumnPickerHeader = styled.th`
-  width: 40px;
+  width: 56px;
+  z-index: 10;
   position: sticky;
   right: calc(-1 * ${tableSidePadding});
   background-color: ${"var(--ds-surface, #FFF)"};
@@ -43,6 +44,7 @@ const ColumnPickerHeader = styled.th`
   &:last-of-type {
     padding-right: ${tableSidePadding};
   }
+  text-align: right; /* In case when TH itself is bigger we want to keep picker at the right side */
 `;
 const truncatedCellStyles = css({
   overflow: 'hidden',
@@ -56,6 +58,7 @@ const scrollableContainerStyles = css({
   borderRadius: "var(--ds-border-radius-100, 3px)"
 });
 const tableStyles = css({
+  tableLayout: 'fixed',
   // These styles are needed to prevent thead bottom border from scrolling away.
   // This happens because it is sticky. https://stackoverflow.com/questions/50361698/border-style-do-not-work-with-sticky-position-element
   borderCollapse: 'separate',
@@ -74,7 +77,7 @@ function extractIndex(data) {
   invariant(typeof index === 'number');
   return index;
 }
-export const orderColumns = (columns, visibleColumnKeys) => {
+export const getOrderedColumns = (columns, visibleColumnKeys) => {
   const visibleColumns = columns.filter(column => visibleColumnKeys.includes(column.key)).sort((a, b) => {
     const indexB = visibleColumnKeys.indexOf(b.key);
     const indexA = visibleColumnKeys.indexOf(a.key);
@@ -84,25 +87,28 @@ export const orderColumns = (columns, visibleColumnKeys) => {
   return [...visibleColumns, ...invisibleColumns];
 };
 const BASE_WIDTH = 8;
-function getColumnWidth(key, type) {
-  const keyBasedWidth = {
-    assignee: BASE_WIDTH * 22,
-    labels: BASE_WIDTH * 22,
-    priority: BASE_WIDTH * 8,
-    status: BASE_WIDTH * 18,
-    summary: BASE_WIDTH * 45,
-    description: BASE_WIDTH * 31.25
-  };
-  if (keyBasedWidth[key]) {
-    return keyBasedWidth[key];
+const DEFAULT_WIDTH = BASE_WIDTH * 22;
+export const COLUMN_MIN_WIDTH = BASE_WIDTH * 3;
+const keyBasedWidthMap = {
+  priority: BASE_WIDTH * 4,
+  status: BASE_WIDTH * 18,
+  summary: BASE_WIDTH * 45,
+  description: BASE_WIDTH * 31.25,
+  type: BASE_WIDTH * 4,
+  key: BASE_WIDTH * 13
+};
+function getDefaultColumnWidth(key, type) {
+  const keyBasedWidth = keyBasedWidthMap[key];
+  if (keyBasedWidth) {
+    return keyBasedWidth;
   }
   switch (type) {
     case 'date':
       return BASE_WIDTH * 14;
-    case 'string':
-      return BASE_WIDTH * 22;
+    case 'icon':
+      return BASE_WIDTH * 4;
     default:
-      return undefined;
+      return DEFAULT_WIDTH;
   }
 }
 export const IssueLikeDataTableView = ({
@@ -114,6 +120,8 @@ export const IssueLikeDataTableView = ({
   renderItem = fallbackRenderType,
   visibleColumnKeys,
   onVisibleColumnKeysChange,
+  columnCustomSizes,
+  onColumnResize,
   status,
   hasNextPage,
   scrollableContainerHeight,
@@ -121,14 +129,15 @@ export const IssueLikeDataTableView = ({
   extensionKey
 }) => {
   const tableId = useMemo(() => Symbol('unique-id'), []);
+  const tableHeaderRowRef = useRef(null);
   const [lastRowElement, setLastRowElement] = useState(null);
   const [hasFullSchema, setHasFullSchema] = useState(false);
   const isBottomOfTableVisibleRaw = useIsOnScreen(lastRowElement);
   const containerRef = useRef(null);
-  const [orderedColumns, setOrderedColumns] = useState(() => orderColumns([...columns], [...visibleColumnKeys]));
+  const [orderedColumns, setOrderedColumns] = useState(() => getOrderedColumns([...columns], [...visibleColumnKeys]));
   useEffect(() => {
     if (!hasFullSchema) {
-      setOrderedColumns(orderColumns([...columns], [...visibleColumnKeys]));
+      setOrderedColumns(getOrderedColumns([...columns], [...visibleColumnKeys]));
     }
   }, [columns, visibleColumnKeys, hasFullSchema]);
   useEffect(() => {
@@ -147,24 +156,8 @@ export const IssueLikeDataTableView = ({
   // or some other combination.
 
   const identityColumnKey = 'id';
-  const loadingRow = useMemo(() => ({
-    key: 'loading',
-    cells: visibleSortedColumns.map(({
-      key
-    }) => {
-      const content = jsx(Skeleton, {
-        borderRadius: 8,
-        width: "100%",
-        height: 14,
-        testId: "issues-table-row-loading"
-      });
-      return {
-        key,
-        content
-      };
-    })
-  }), [visibleSortedColumns]);
-  const headColumns = useMemo(() => visibleSortedColumns.map(({
+  const getColumnWidth = useCallback((key, type) => (columnCustomSizes === null || columnCustomSizes === void 0 ? void 0 : columnCustomSizes[key]) || getDefaultColumnWidth(key, type), [columnCustomSizes]);
+  const headerColumns = useMemo(() => visibleSortedColumns.map(({
     key,
     title,
     type
@@ -172,8 +165,20 @@ export const IssueLikeDataTableView = ({
     key,
     content: title,
     shouldTruncate: true,
-    maxWidth: getColumnWidth(key, type)
-  })), [visibleSortedColumns]);
+    width: getColumnWidth(key, type)
+  })), [getColumnWidth, visibleSortedColumns]);
+  const loadingRow = useMemo(() => ({
+    key: 'loading',
+    cells: headerColumns.map(column => ({
+      ...column,
+      content: jsx(Skeleton, {
+        borderRadius: 8,
+        width: "100%",
+        height: 14,
+        testId: "issues-table-row-loading"
+      })
+    }))
+  }), [headerColumns]);
   useEffect(() => {
     if (isBottomOfTableVisibleRaw && hasNextPage && status === 'resolved') {
       void onNextPage({
@@ -193,32 +198,38 @@ export const IssueLikeDataTableView = ({
     }
     return combine(monitorForElements({
       onDragStart: ({
-        location
+        location,
+        source
       }) => {
-        var _containerRef$current;
         initialAutoScrollerClientY.current = location.current.input.clientY;
-        autoScroller.start({
-          input: {
-            ...location.current.input,
-            clientY:
-            // The goal is to have clientY the same and in the middle of the scrollable area
-            // Since clientY is taken from to of the viewport we need to plus that in order to get
-            // middle of the scrollable area in reference to the viewport
-            (initialAutoScrollerClientY.current || 0) + (((_containerRef$current = containerRef.current) === null || _containerRef$current === void 0 ? void 0 : _containerRef$current.offsetHeight) || 0) / 2
-          },
-          behavior: 'container-only'
-        });
+        if (source.data.type === 'table-header') {
+          var _containerRef$current;
+          autoScroller.start({
+            input: {
+              ...location.current.input,
+              clientY:
+              // The goal is to have clientY the same and in the middle of the scrollable area
+              // Since clientY is taken from to of the viewport we need to plus that in order to get
+              // middle of the scrollable area in reference to the viewport
+              (initialAutoScrollerClientY.current || 0) + (((_containerRef$current = containerRef.current) === null || _containerRef$current === void 0 ? void 0 : _containerRef$current.offsetHeight) || 0) / 2
+            },
+            behavior: 'container-only'
+          });
+        }
       },
       onDrag: ({
-        location
+        location,
+        source
       }) => {
-        var _containerRef$current2;
-        autoScroller.updateInput({
-          input: {
-            ...location.current.input,
-            clientY: (initialAutoScrollerClientY.current || 0) + (((_containerRef$current2 = containerRef.current) === null || _containerRef$current2 === void 0 ? void 0 : _containerRef$current2.offsetHeight) || 0) / 2
-          }
-        });
+        if (source.data.type === 'table-header') {
+          var _containerRef$current2;
+          autoScroller.updateInput({
+            input: {
+              ...location.current.input,
+              clientY: (initialAutoScrollerClientY.current || 0) + (((_containerRef$current2 = containerRef.current) === null || _containerRef$current2 === void 0 ? void 0 : _containerRef$current2.offsetHeight) || 0) / 2
+            }
+          });
+        }
       },
       onDrop({
         source,
@@ -247,9 +258,7 @@ export const IssueLikeDataTableView = ({
           onVisibleColumnKeysChange === null || onVisibleColumnKeysChange === void 0 ? void 0 : onVisibleColumnKeysChange([...newColumnKeyOrder]);
 
           // We sort columns (whole objects) according to their key order presented in newColumnKeyOrder
-          setOrderedColumns(columns => {
-            return orderColumns([...columns], [...newColumnKeyOrder]);
-          });
+          setOrderedColumns(columns => getOrderedColumns([...columns], [...newColumnKeyOrder]));
         }
       }
     }));
@@ -270,11 +279,11 @@ export const IssueLikeDataTableView = ({
       return {
         key,
         content: content.length === 1 ? content[0] : content,
-        maxWidth: getColumnWidth(key, type)
+        width: getColumnWidth(key, type)
       };
     }),
     ref: rowIndex === items.length - 1 ? el => setLastRowElement(el) : undefined
-  })), [identityColumnKey, renderItem, items, visibleSortedColumns]);
+  })), [items, visibleSortedColumns, getColumnWidth, renderItem]);
   const rows = useMemo(() => {
     if (status !== 'loading') {
       return tableRows;
@@ -328,10 +337,12 @@ export const IssueLikeDataTableView = ({
   }, jsx("thead", {
     "data-testid": testId && `${testId}--head`,
     css: [noDefaultBorderStyles, tableHeadStyles]
-  }, jsx("tr", null, headColumns.map(({
+  }, jsx("tr", {
+    ref: tableHeaderRowRef
+  }, headerColumns.map(({
     key,
     content,
-    maxWidth
+    width
   }, cellIndex) => {
     const heading = jsx(Tooltip, {
       content: content,
@@ -362,7 +373,8 @@ export const IssueLikeDataTableView = ({
         key: key,
         id: key,
         index: cellIndex,
-        maxWidth: maxWidth,
+        width: width,
+        onWidthChange: onColumnResize === null || onColumnResize === void 0 ? void 0 : onColumnResize.bind(null, key),
         dndPreviewHeight: ((_containerRef$current3 = containerRef.current) === null || _containerRef$current3 === void 0 ? void 0 : _containerRef$current3.offsetHeight) || 0,
         dragPreview: dragPreview
       }, heading);
@@ -371,9 +383,7 @@ export const IssueLikeDataTableView = ({
         key: key,
         "data-testid": `${key}-column-heading`,
         style: {
-          // this keeps the column headers from collapsing horizontally during loading states
-          minWidth: maxWidth,
-          maxWidth
+          width
         }
       }, heading);
     }
@@ -397,10 +407,10 @@ export const IssueLikeDataTableView = ({
   }, cells.map(({
     key: cellKey,
     content,
-    maxWidth
+    width
   }, cellIndex) => {
     let loadingRowStyle = {
-      maxWidth
+      width
     };
     // extra padding is required around skeleton loader to avoid vertical jumps when data loads
     if (key !== null && key !== void 0 && key.includes('loading')) {

package/dist/es2019/ui/jira-issues-modal/basic-filters/mocks/fieldValuesEmptyResponse.js

@@ -0,0 +1,14 @@
+export const fieldValuesEmptyResponse = {
+  data: {
+    jira: {
+      jqlBuilder: {
+        fieldValues: {
+          totalCount: 0,
+          pageInfo: {},
+          edges: []
+        }
+      }
+    }
+  }
+};
+export const fieldValuesEmptyResponseMapped = [];