@atlaskit/smart-card 45.20.7 → 45.21.1

package/dist/es2019/view/FlexibleCard/components/actions/automation-action/automation-manual-triggers/manual-triggers-container/ManualRulesContainer.js

@@ -0,0 +1,126 @@
+import React, { useMemo, useState } from 'react';
+import { di } from 'react-magnetic-di';
+import ModalTransition from '@atlaskit/modal-dialog/modal-transition';
+import UserInputForm from './manual-triggers-form/main';
+import { invokeManuallyTriggeredRule } from './services/invokeManuallyTriggeredRule';
+import { useManualRules } from './useManualRules';
+
+/**
+ *
+ * Container HOC that implements the above hook and behaviours.
+ *
+ * This HOC uses rendered props to allow the use of any render instructions
+ * for manual rules, while still maintaining the behaviour of invoking rules.
+ *
+ * The HOC also appends a dialog that is displayed when the {@code invokeRuleOrShowDialog}
+ * prop is called, if the underlying rule has user inputs.
+ *
+ * The component exposes the "invokingRuleId" property to the child hierarchy,
+ * because the children might care about the invocation state. It does not expose
+ * the "selected" state, or any information about the dialog, as the children
+ * should not care about this, only how to trigger invocation and understand
+ * the invocation lifecycle.
+ *
+ * @param props - cloudId, projectId, children
+ */
+export const ManualRulesContainer = props => {
+  const {
+    site,
+    query,
+    children,
+    onInputsModalOpened,
+    onInputsModalClosed,
+    onRuleInvocationLifecycleStarted,
+    onRuleInvocationSuccess,
+    onRuleInvocationFailure,
+    onRuleInvocationLifecycleDone
+  } = props;
+  // Initial data loading state
+  const [triggerFetch, initialised, error, rules] = useManualRules(site, query);
+  // We store a rule in state here if and only if a rule has user inputs, and thus
+  // we need to preserve state while the input dialog is open.
+  const [selectedRule, setSelectedRule] = useState(null);
+  const clearSelectedRule = () => {
+    setSelectedRule(null);
+  };
+  // Value set when a rule is invoking, either from the dialog or without dialog
+  const [invokingRuleId, setInvokingRuleId] = useState(null);
+
+  // Memoized projection of rules by id
+  const rulesById = useMemo(() => rules.reduce((acc, rule) => ({
+    // eslint-disable-next-line
+    ...acc,
+    [rule.id]: rule
+  }), {}), [rules]);
+  const getRule = id => rulesById[id];
+  const ruleHasInputs = rule => {
+    var _rule$userInputPrompt;
+    return (rule === null || rule === void 0 ? void 0 : (_rule$userInputPrompt = rule.userInputPrompts) === null || _rule$userInputPrompt === void 0 ? void 0 : _rule$userInputPrompt.length) > 0;
+  };
+  const getFailedObjects = response => Object.keys(response).filter(object => response[object] !== 'SUCCESS');
+  const getSuccessfulObjects = response => Object.keys(response).filter(object => response[object] === 'SUCCESS');
+  const handleInvocationFailure = (ruleId, successfulObjects, failedObjects) => {
+    if (onRuleInvocationFailure) {
+      onRuleInvocationFailure(ruleId, successfulObjects, failedObjects);
+    }
+  };
+  const invokeRule = async (ruleId, objects, userInputs) => {
+    const rule = getRule(ruleId);
+    if (rule) {
+      setInvokingRuleId(ruleId);
+      try {
+        if (onRuleInvocationLifecycleStarted) {
+          onRuleInvocationLifecycleStarted(ruleId, objects, userInputs);
+        }
+        const response = await invokeManuallyTriggeredRule(site, ruleId, objects, userInputs);
+        const failedObjects = getFailedObjects(response);
+        setInvokingRuleId(null);
+        if (failedObjects.length === 0) {
+          if (onRuleInvocationSuccess) {
+            onRuleInvocationSuccess(ruleId, objects);
+          }
+        } else {
+          const successfulObjects = getSuccessfulObjects(response);
+          handleInvocationFailure(ruleId, successfulObjects, failedObjects);
+        }
+      } catch (e) {
+        handleInvocationFailure(ruleId, [], objects);
+        setInvokingRuleId(null);
+      }
+    } else {
+      handleInvocationFailure(ruleId, [], objects);
+    }
+    clearSelectedRule();
+    if (onRuleInvocationLifecycleDone) {
+      onRuleInvocationLifecycleDone(ruleId, objects);
+    }
+  };
+  const invokeRuleOrShowDialog = (ruleId, objects) => {
+    const rule = getRule(ruleId);
+    if (!rule) {
+      return handleInvocationFailure(ruleId, [], objects);
+    }
+    if (ruleHasInputs(rule)) {
+      setSelectedRule({
+        rule,
+        objects
+      });
+    } else {
+      invokeRule(ruleId, objects);
+    }
+  };
+  return /*#__PURE__*/React.createElement(React.Fragment, null, children({
+    triggerFetch,
+    initialised,
+    error,
+    rules,
+    invokingRuleId,
+    invokeRuleOrShowDialog
+  }), /*#__PURE__*/React.createElement(ModalTransition, null, selectedRule && /*#__PURE__*/React.createElement(UserInputForm, {
+    onInputsModalOpened: onInputsModalOpened,
+    onInputsModalClosed: onInputsModalClosed,
+    clearSelectedRule: clearSelectedRule,
+    selectedRule: selectedRule,
+    invokeRule: invokeRule
+  })));
+};

package/dist/es2019/view/FlexibleCard/components/actions/automation-action/automation-manual-triggers/manual-triggers-container/common/create-generic-component.js

@@ -0,0 +1,19 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { Component } from 'react';
+export const createGenericComponent = (displayName, renderChildren = true, childrenParams) => {
+  var _Class;
+  return _Class = class extends Component {
+    render() {
+      if (renderChildren && typeof this.props.children === 'function') {
+        if (childrenParams) {
+          return this.props.children(childrenParams);
+        }
+        return this.props.children();
+      }
+      if (renderChildren && this.props.children) {
+        return this.props.children;
+      }
+      return null;
+    }
+  }, _defineProperty(_Class, "displayName", displayName), _Class;
+};

package/dist/es2019/view/FlexibleCard/components/actions/automation-action/automation-manual-triggers/manual-triggers-container/common/create-stub-invoke-manually-triggered-rule.js

@@ -0,0 +1,12 @@
+/**
+ * Creates a stubbed invocation API call for triggering rules. Will return
+ * the supplied invocation result for all objects the rule was called
+ * for.
+ */
+export const createStubInvokeManuallyTriggeredRule = (stubbedInvocationResultForAllObjects, responseDelay) => async (_env, _site, _ruleId, objects, _inputs) => {
+  const response = objects.reduce((acc, current) => ({
+    ...acc,
+    [current]: stubbedInvocationResultForAllObjects
+  }), {});
+  return responseDelay ? new Promise(resolve => setTimeout(resolve, responseDelay)) : Promise.resolve(response);
+};

package/dist/es2019/view/FlexibleCard/components/actions/automation-action/automation-manual-triggers/manual-triggers-container/common/test-utils/render-with-di.js

@@ -0,0 +1,37 @@
+import React, { Fragment } from 'react';
+import { render } from '@atlassian/testing-library';
+import { IntlProvider } from 'react-intl'; // eslint-disable-line import/no-extraneous-dependencies
+import { DiProvider } from 'react-magnetic-di';
+const Provider = ({
+  children,
+  use,
+  target
+}) => /*#__PURE__*/React.createElement(IntlProvider, {
+  locale: "en"
+}, /*#__PURE__*/React.createElement(DiProvider, {
+  use: use,
+  target: target
+}, children));
+
+/**
+ * Render into a container which is appended to `document.body`.
+ *
+ * Includes `IntlProvider` wrapper
+ *
+ * @param node The React element to render
+ * @param dependencies List of React Magnetic DI dependencies to inject
+ * @param options React Testing Library options
+ */
+export const renderWithDi = (node, dependencies = [], options) => render(node, {
+  ...options,
+  wrapper({
+    children
+  }) {
+    var _options$wrapper;
+    const CustomWrapper = (_options$wrapper = options === null || options === void 0 ? void 0 : options.wrapper) !== null && _options$wrapper !== void 0 ? _options$wrapper : Fragment;
+    return /*#__PURE__*/React.createElement(Provider, {
+      use: [...dependencies],
+      target: options === null || options === void 0 ? void 0 : options.target
+    }, /*#__PURE__*/React.createElement(CustomWrapper, null, children));
+  }
+});

package/dist/es2019/view/FlexibleCard/components/actions/automation-action/automation-manual-triggers/manual-triggers-container/common/utils/_performRequest.js

@@ -0,0 +1,9 @@
+import { DEFAULT_HEADER } from './default-header';
+export const _performRequest = async (url, method, options) => {
+  const response = await fetch(url, {
+    headers: DEFAULT_HEADER,
+    ...options,
+    method
+  });
+  return response.json();
+};

package/dist/es2019/view/FlexibleCard/components/actions/automation-action/automation-manual-triggers/manual-triggers-container/common/utils/default-header.js

@@ -0,0 +1,3 @@
+export const DEFAULT_HEADER = {
+  'Content-Type': 'application/json'
+};

package/dist/es2019/view/FlexibleCard/components/actions/automation-action/automation-manual-triggers/manual-triggers-container/common/utils/extractCloudIdAndProductFromSite.js

@@ -0,0 +1,28 @@
+/**
+ * This function will extract the cloud ID and product from a product level Site ARI.
+ * ARIs can be found at the following link: {@link https://developer.atlassian.com/platform/atlassian-resource-identifier/resource-owners/registry/#ari-registry}
+ * @param site The Site ARI where the manual trigger rule is executed. Should be a product level Site ARI.
+ */
+export const extractCloudIdAndProductFromSite = site => {
+  let cloudId;
+  let resourceOwner;
+  let resourceType;
+  const ariRegex = new RegExp('^ari:cloud:([a-zA-Z.\\-]+)::([a-zA-Z.\\-]+)/([a-zA-Z0-9\\-]+)');
+  const parsedAri = site.match(ariRegex);
+  if (parsedAri) {
+    resourceOwner = parsedAri[1];
+    resourceType = parsedAri[2];
+    cloudId = parsedAri[3];
+  }
+  // Keep backwards compatibility for platform site ARIs
+  if (resourceOwner === 'platform') {
+    resourceOwner = 'jira';
+  }
+  if (resourceType !== 'site' || cloudId === undefined || resourceOwner === undefined) {
+    throw new Error('Not a site ARI: ' + site);
+  }
+  return {
+    product: resourceOwner,
+    cloudId: cloudId
+  };
+};

package/dist/es2019/view/FlexibleCard/components/actions/automation-action/automation-manual-triggers/manual-triggers-container/common/utils/getInvocationUrl.js

@@ -0,0 +1,8 @@
+import { extractCloudIdAndProductFromSite } from './extractCloudIdAndProductFromSite';
+export const getInvocationUrl = async (site, ruleId) => {
+  const {
+    product,
+    cloudId
+  } = extractCloudIdAndProductFromSite(site);
+  return `/gateway/api/automation/public/${product}/${cloudId}/rest/v1/rule/manual/${ruleId}/invocation`;
+};

package/dist/es2019/view/FlexibleCard/components/actions/automation-action/automation-manual-triggers/manual-triggers-container/common/utils/getSearchUrl.js

@@ -0,0 +1,24 @@
+import { extractCloudIdAndProductFromSite } from './extractCloudIdAndProductFromSite';
+
+/***
+ * TODO remove when unified public API is available.
+ *
+ * Currently we're in a transitory phase where we have one API for invocation for Jira, and one for JSM. They concern themselves
+ * with issues and alerts respectively.
+ *
+ * We are working on a unified public API that only cares about product-agnostic filters like object, workspace, container as
+ * part of the collaboration model. For the meantime, you'll see two APIs instead. In this package, we're only using the
+ * alerts API. It is this API that will be expanded to retroactively support Jira, and thus the updated collaboration
+ * model language is used here, even though for the meantime we only concern ourselves with alerts.
+ *
+ */
+export const getSearchUrl = async site => {
+  const {
+    product,
+    cloudId
+  } = extractCloudIdAndProductFromSite(site);
+  // TODO in the unified API, GET requests as according to Atlassian API standards will destructure the whole query into
+  // query parameters as part of the URL. For now, this is considered a POST request instead and thus the query is used
+  // later on as the request body.
+  return `/gateway/api/automation/public/${product}/${cloudId}/rest/v1/rule/manual/search`;
+};

package/dist/es2019/view/FlexibleCard/components/actions/automation-action/automation-manual-triggers/manual-triggers-container/common/utils/performGetRequest.js

@@ -0,0 +1,4 @@
+import { _performRequest } from './_performRequest';
+export const performGetRequest = async (url, options) => {
+  return _performRequest(url, 'GET', options);
+};

package/dist/es2019/view/FlexibleCard/components/actions/automation-action/automation-manual-triggers/manual-triggers-container/common/utils/performPostRequest.js

@@ -0,0 +1,4 @@
+import { _performRequest } from './_performRequest';
+export const performPostRequest = async (url, options) => {
+  return _performRequest(url, 'POST', options);
+};

package/dist/es2019/view/FlexibleCard/components/actions/automation-action/automation-manual-triggers/manual-triggers-container/main.js

@@ -1,154 +1 @@
-import React, { useMemo, useState } from 'react';
-import { di } from 'react-magnetic-di';
-import ModalTransition from '@atlaskit/modal-dialog/modal-transition';
-import UserInputForm from './manual-triggers-form/main';
-import { invokeManuallyTriggeredRule, searchManuallyTriggeredRules } from './services';
-
-/**
- * React hook that implements the fetch and invoke actions for manual triggers.
- * Can be used standalone or in the HOC provided below.
- * @param site - The site to filter on. We map this to just a cloudId to resolve the manual rules API path
- * @param query - Query object containing filter props (container, object(s))
- */
-export const useManualRules = (site, query) => {
-  const [initialised, setInitialised] = useState(false);
-  const [error, setError] = useState(null);
-  const [rules, setRules] = useState([]);
-  const transformRules = ruleResponse => {
-    const rulesUnsorted = Object.values(ruleResponse);
-    return rulesUnsorted.sort((rule1, rule2) => rule1.name.localeCompare(rule2.name));
-  };
-  const triggerFetch = async () => {
-    setInitialised(false);
-    try {
-      const fetchedRules = await searchManuallyTriggeredRules(site, query);
-      setError(null);
-      setRules(transformRules(fetchedRules));
-    } catch (e) {
-      setError(e);
-      setRules([]);
-    } finally {
-      setInitialised(true);
-    }
-  };
-  return [triggerFetch, initialised, error, rules];
-};
-/**
- *
- * Container HOC that implements the above hook and behaviours.
- *
- * This HOC uses rendered props to allow the use of any render instructions
- * for manual rules, while still maintaining the behaviour of invoking rules.
- *
- * The HOC also appends a dialog that is displayed when the {@code invokeRuleOrShowDialog}
- * prop is called, if the underlying rule has user inputs.
- *
- * The component exposes the "invokingRuleId" property to the child hierarchy,
- * because the children might care about the invocation state. It does not expose
- * the "selected" state, or any information about the dialog, as the children
- * should not care about this, only how to trigger invocation and understand
- * the invocation lifecycle.
- *
- * @param props - cloudId, projectId, children
- */
-export const ManualRulesContainer = props => {
-  const {
-    site,
-    query,
-    children,
-    onInputsModalOpened,
-    onInputsModalClosed,
-    onRuleInvocationLifecycleStarted,
-    onRuleInvocationSuccess,
-    onRuleInvocationFailure,
-    onRuleInvocationLifecycleDone
-  } = props;
-  // Initial data loading state
-  const [triggerFetch, initialised, error, rules] = useManualRules(site, query);
-  // We store a rule in state here if and only if a rule has user inputs, and thus
-  // we need to preserve state while the input dialog is open.
-  const [selectedRule, setSelectedRule] = useState(null);
-  const clearSelectedRule = () => {
-    setSelectedRule(null);
-  };
-  // Value set when a rule is invoking, either from the dialog or without dialog
-  const [invokingRuleId, setInvokingRuleId] = useState(null);
-
-  // Memoized projection of rules by id
-  const rulesById = useMemo(() => rules.reduce((acc, rule) => ({
-    // eslint-disable-next-line
-    ...acc,
-    [rule.id]: rule
-  }), {}), [rules]);
-  const getRule = id => rulesById[id];
-  const ruleHasInputs = rule => {
-    var _rule$userInputPrompt;
-    return (rule === null || rule === void 0 ? void 0 : (_rule$userInputPrompt = rule.userInputPrompts) === null || _rule$userInputPrompt === void 0 ? void 0 : _rule$userInputPrompt.length) > 0;
-  };
-  const getFailedObjects = response => Object.keys(response).filter(object => response[object] !== 'SUCCESS');
-  const getSuccessfulObjects = response => Object.keys(response).filter(object => response[object] === 'SUCCESS');
-  const handleInvocationFailure = (ruleId, successfulObjects, failedObjects) => {
-    if (onRuleInvocationFailure) {
-      onRuleInvocationFailure(ruleId, successfulObjects, failedObjects);
-    }
-  };
-  const invokeRule = async (ruleId, objects, userInputs) => {
-    const rule = getRule(ruleId);
-    if (rule) {
-      setInvokingRuleId(ruleId);
-      try {
-        if (onRuleInvocationLifecycleStarted) {
-          onRuleInvocationLifecycleStarted(ruleId, objects, userInputs);
-        }
-        const response = await invokeManuallyTriggeredRule(site, ruleId, objects, userInputs);
-        const failedObjects = getFailedObjects(response);
-        setInvokingRuleId(null);
-        if (failedObjects.length === 0) {
-          if (onRuleInvocationSuccess) {
-            onRuleInvocationSuccess(ruleId, objects);
-          }
-        } else {
-          const successfulObjects = getSuccessfulObjects(response);
-          handleInvocationFailure(ruleId, successfulObjects, failedObjects);
-        }
-      } catch (e) {
-        handleInvocationFailure(ruleId, [], objects);
-        setInvokingRuleId(null);
-      }
-    } else {
-      handleInvocationFailure(ruleId, [], objects);
-    }
-    clearSelectedRule();
-    if (onRuleInvocationLifecycleDone) {
-      onRuleInvocationLifecycleDone(ruleId, objects);
-    }
-  };
-  const invokeRuleOrShowDialog = (ruleId, objects) => {
-    const rule = getRule(ruleId);
-    if (!rule) {
-      return handleInvocationFailure(ruleId, [], objects);
-    }
-    if (ruleHasInputs(rule)) {
-      setSelectedRule({
-        rule,
-        objects
-      });
-    } else {
-      invokeRule(ruleId, objects);
-    }
-  };
-  return /*#__PURE__*/React.createElement(React.Fragment, null, children({
-    triggerFetch,
-    initialised,
-    error,
-    rules,
-    invokingRuleId,
-    invokeRuleOrShowDialog
-  }), /*#__PURE__*/React.createElement(ModalTransition, null, selectedRule && /*#__PURE__*/React.createElement(UserInputForm, {
-    onInputsModalOpened: onInputsModalOpened,
-    onInputsModalClosed: onInputsModalClosed,
-    clearSelectedRule: clearSelectedRule,
-    selectedRule: selectedRule,
-    invokeRule: invokeRule
-  })));
-};
+export {};

package/dist/es2019/view/FlexibleCard/components/actions/automation-action/automation-manual-triggers/manual-triggers-container/manual-triggers-form/number-prompt/main.js

@@ -6,20 +6,12 @@ import { MessageWrapper } from '@atlaskit/form/message-wrapper';
 import { fg } from '@atlaskit/platform-feature-flags/fg';
 import Textfield from '@atlaskit/textfield/text-field';
 import messages from '../../common/messages';
+import { numberValidate } from './numberValidate';
 export let Errors = /*#__PURE__*/function (Errors) {
   Errors["EMPTY"] = "EMPTY";
   Errors["INVALID_NUMBER"] = "INVALID_NUMBER";
   return Errors;
 }({});
-export const numberValidate = (isRequired, value) => {
-  if (isRequired && !value) {
-    return Errors.EMPTY;
-  }
-  if (value && Number.isNaN(Number(value))) {
-    return Errors.INVALID_NUMBER;
-  }
-  return undefined;
-};
 const NumberInputPrompt = ({
   userInputPrompt
 }) => {

package/dist/es2019/view/FlexibleCard/components/actions/automation-action/automation-manual-triggers/manual-triggers-container/manual-triggers-form/number-prompt/numberValidate.js

@@ -0,0 +1,10 @@
+import { Errors } from './main';
+export const numberValidate = (isRequired, value) => {
+  if (isRequired && !value) {
+    return Errors.EMPTY;
+  }
+  if (value && Number.isNaN(Number(value))) {
+    return Errors.INVALID_NUMBER;
+  }
+  return undefined;
+};

package/dist/es2019/view/FlexibleCard/components/actions/automation-action/automation-manual-triggers/manual-triggers-container/services/invokeManuallyTriggeredRule.js

@@ -0,0 +1,22 @@
+import { getInvocationUrl } from '../common/utils/getInvocationUrl';
+import { performPostRequest } from '../common/utils/performPostRequest';
+
+/**
+ * Invoke a manually triggered rule via the API.
+ * @param cloudId - the site the rule belongs to
+ * @param ruleId - the identifier of the rule you want to invoke
+ * @param objects - the list of objects you wish to create an automation event for.
+ * @param userInputs - the optional user inputs if this manual trigger requires them
+ */
+export const invokeManuallyTriggeredRule = async (site, ruleId, objects, userInputs) => {
+  const url = await getInvocationUrl(site, ruleId);
+  const bodyRaw = {
+    objects
+  };
+  if (userInputs) {
+    bodyRaw.userInputs = userInputs;
+  }
+  return performPostRequest(url, {
+    body: JSON.stringify(bodyRaw)
+  });
+};

package/dist/es2019/view/FlexibleCard/components/actions/automation-action/automation-manual-triggers/manual-triggers-container/services/searchManuallyTriggeredRules.js

@@ -0,0 +1,33 @@
+import { getSearchUrl } from '../common/utils/getSearchUrl';
+import { performPostRequest } from '../common/utils/performPostRequest';
+
+/**
+ * Manual trigger rules API fetch. Fetches a list of manually triggered rules according to the context provided
+ * in query.
+ * @param site - the site ARI to fetch the rules against
+ * @param query - the workspace/container/objects to fetch rules against
+ */
+export const searchManuallyTriggeredRules = async (site, query) => {
+  const url = await getSearchUrl(site);
+  // TODO this will in the new API be a GET request instead, with the above getSearchUrl method
+  // constructing a URL with the appropriate query parameters. For now, instead, we pass the
+  // destructured query through as a POST body.
+  const response = await performPostRequest(url, {
+    body: JSON.stringify(query)
+  });
+  return response.data.reduce((acc, {
+    id,
+    name,
+    ruleScope,
+    userInputs
+  }) => ({
+    // eslint-disable-next-line
+    ...acc,
+    [id]: {
+      id,
+      name,
+      ruleScope,
+      userInputPrompts: userInputs
+    }
+  }), {});
+};

package/dist/es2019/view/FlexibleCard/components/actions/automation-action/automation-manual-triggers/manual-triggers-container/useManualRules.js

@@ -0,0 +1,32 @@
+import { useState } from 'react';
+import { searchManuallyTriggeredRules } from './services/searchManuallyTriggeredRules';
+
+/**
+ * React hook that implements the fetch and invoke actions for manual triggers.
+ * Can be used standalone or in the HOC provided below.
+ * @param site - The site to filter on. We map this to just a cloudId to resolve the manual rules API path
+ * @param query - Query object containing filter props (container, object(s))
+ */
+export const useManualRules = (site, query) => {
+  const [initialised, setInitialised] = useState(false);
+  const [error, setError] = useState(null);
+  const [rules, setRules] = useState([]);
+  const transformRules = ruleResponse => {
+    const rulesUnsorted = Object.values(ruleResponse);
+    return rulesUnsorted.sort((rule1, rule2) => rule1.name.localeCompare(rule2.name));
+  };
+  const triggerFetch = async () => {
+    setInitialised(false);
+    try {
+      const fetchedRules = await searchManuallyTriggeredRules(site, query);
+      setError(null);
+      setRules(transformRules(fetchedRules));
+    } catch (e) {
+      setError(e);
+      setRules([]);
+    } finally {
+      setInitialised(true);
+    }
+  };
+  return [triggerFetch, initialised, error, rules];
+};

package/dist/es2019/view/FlexibleCard/components/actions/automation-action/automation-manual-triggers/manual-triggers-modal/index.js

@@ -1,3 +1,2 @@
 import { AutomationModal } from './main';
-export { AutomationModal } from './main';
 export default AutomationModal;

package/dist/es2019/view/FlexibleCard/components/actions/automation-action/automation-manual-triggers/manual-triggers-modal/main.js

@@ -3,7 +3,7 @@ import { useAnalyticsEvents } from '@atlaskit/analytics-next/useAnalyticsEvents'
 import Modal from '@atlaskit/modal-dialog/modal-dialog';
 import ModalBody from '@atlaskit/modal-dialog/modal-body';
 import ModalFooter from '@atlaskit/modal-dialog/modal-footer';
-import { AutomationMenuContextContainer } from './menu-context';
+import { AutomationMenuContextContainer } from './menu-context/AutomationMenuContextContainer';
 import { AutomationModalBody } from './sub-components/body';
 import { AutomationModalExecutionState } from './sub-components/execution-state-message';
 import { AutomationModalFooter } from './sub-components/footer';

package/dist/es2019/view/FlexibleCard/components/actions/automation-action/automation-manual-triggers/manual-triggers-modal/menu-context/AutomationMenuContext.js

@@ -0,0 +1,6 @@
+// This is another layer on top of the AFE ManualRulesContainer.
+// It is necessary that this container wraps the entire "automation" component and not nested. Else the user input form will not render correctly.
+// This container provides an automation context to all children components through the useAutomationMenu hook.
+
+import { createContext } from 'react';
+export const AutomationMenuContext = /*#__PURE__*/createContext(undefined);

package/dist/es2019/view/FlexibleCard/components/actions/automation-action/automation-manual-triggers/manual-triggers-modal/menu-context/AutomationMenuContextContainer.js

@@ -0,0 +1,55 @@
+// This is another layer on top of the AFE ManualRulesContainer.
+// It is necessary that this container wraps the entire "automation" component and not nested. Else the user input form will not render correctly.
+// This container provides an automation context to all children components through the useAutomationMenu hook.
+
+import React, { useState } from 'react';
+import { ManualRulesContainer } from '../../manual-triggers-container/ManualRulesContainer';
+import { AutomationMenuProvider } from './AutomationMenuProvider';
+export const AutomationMenuContextContainer = ({
+  baseAutomationUrl,
+  analyticsSource,
+  objectAri,
+  siteAri,
+  canManageAutomation,
+  children,
+  emptyStateDescription,
+  emptyStateAdminDescription,
+  onRuleInvocationSuccess,
+  onRuleInvocationFailure,
+  onRuleInvocationLifecycleDone
+}) => {
+  const [ruleExecutionState, setRuleExecutionState] = useState('NONE');
+  return /*#__PURE__*/React.createElement(ManualRulesContainer, {
+    site: siteAri,
+    query: {
+      objects: [objectAri]
+    },
+    onRuleInvocationLifecycleStarted: () => {
+      setRuleExecutionState('NONE');
+    },
+    onRuleInvocationLifecycleDone: onRuleInvocationLifecycleDone,
+    onRuleInvocationSuccess: () => {
+      setRuleExecutionState('SUCCEED');
+      onRuleInvocationSuccess === null || onRuleInvocationSuccess === void 0 ? void 0 : onRuleInvocationSuccess();
+    },
+    onRuleInvocationFailure: () => {
+      setRuleExecutionState('FAILURE');
+      onRuleInvocationFailure === null || onRuleInvocationFailure === void 0 ? void 0 : onRuleInvocationFailure();
+    }
+  }, props => {
+    const contextValue = {
+      ...props,
+      fetchError: props.error,
+      analyticsSource,
+      objectAri,
+      baseAutomationUrl,
+      canManageAutomation,
+      emptyStateDescription,
+      emptyStateAdminDescription,
+      ruleExecutionState
+    };
+    return /*#__PURE__*/React.createElement(AutomationMenuProvider, {
+      value: contextValue
+    }, children());
+  });
+};

package/dist/es2019/view/FlexibleCard/components/actions/automation-action/automation-manual-triggers/manual-triggers-modal/menu-context/AutomationMenuProvider.js

@@ -0,0 +1,15 @@
+// This is another layer on top of the AFE ManualRulesContainer.
+import React from 'react';
+
+// It is necessary that this container wraps the entire "automation" component and not nested. Else the user input form will not render correctly.
+// This container provides an automation context to all children components through the useAutomationMenu hook.
+
+import { AutomationMenuContext } from './AutomationMenuContext';
+export const AutomationMenuProvider = ({
+  children,
+  value
+}) => {
+  return /*#__PURE__*/React.createElement(AutomationMenuContext.Provider, {
+    value: value
+  }, children);
+};