@atlaskit/smart-card 26.69.1 → 26.71.0

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

@@ -0,0 +1,156 @@
+import React, { useMemo, useState } from 'react';
+import { di } from 'react-magnetic-di';
+import { ModalTransition } from '@atlaskit/modal-dialog';
+import { invokeManuallyTriggeredRule, searchManuallyTriggeredRules } from './services';
+import UserInputForm from './manual-triggers-form/main';
+
+/**
+ * React hook that implements the fetch and invoke actions for manual triggers.
+ * Can be used standalone or in the HOC provided below.
+ * @param env - The environment to retrieve rules from
+ * @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 = (env, 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(env, 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 - environment, cloudId, projectId, children
+ */
+export const ManualRulesContainer = props => {
+  const {
+    env,
+    site,
+    query,
+    children,
+    onInputsModalOpened,
+    onInputsModalClosed,
+    onRuleInvocationLifecycleStarted,
+    onRuleInvocationSuccess,
+    onRuleInvocationFailure,
+    onRuleInvocationLifecycleDone
+  } = props;
+  // Initial data loading state
+  const [triggerFetch, initialised, error, rules] = useManualRules(env, 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(env, 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/manual-triggers-form/boolean-prompt/main.js

@@ -0,0 +1,23 @@
+import _extends from "@babel/runtime/helpers/extends";
+import React from 'react';
+import { di } from 'react-magnetic-di';
+import Checkbox from '@atlaskit/checkbox';
+import { CheckboxField } from '@atlaskit/form';
+const BooleanInputPrompt = ({
+  userInputPrompt
+}) => {
+  const {
+    variableName,
+    displayName,
+    defaultValue
+  } = userInputPrompt;
+  return /*#__PURE__*/React.createElement(CheckboxField, {
+    name: variableName,
+    defaultIsChecked: defaultValue || false
+  }, ({
+    fieldProps
+  }) => /*#__PURE__*/React.createElement(Checkbox, _extends({}, fieldProps, {
+    label: displayName
+  })));
+};
+export default BooleanInputPrompt;

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

@@ -0,0 +1,126 @@
+import React from 'react';
+import { di } from 'react-magnetic-di';
+import Button from '@atlaskit/button/new';
+import Form, { ErrorMessage, FormSection } from '@atlaskit/form';
+import Modal, { ModalBody, ModalFooter, ModalHeader, ModalTitle } from '@atlaskit/modal-dialog';
+import messages from '../common/messages';
+import { UserInputType } from '../common/types';
+import BooleanInputPrompt from './boolean-prompt/main';
+import NumberInputPrompt from './number-prompt/main';
+import ParagraphInputPrompt from './paragraph-prompt/main';
+import SelectInputPrompt from './select-prompt/main';
+import TextInputPrompt from './text-prompt/main';
+const UserInputForm = props => {
+  const {
+    selectedRule,
+    clearSelectedRule,
+    invokeRule,
+    onInputsModalOpened,
+    onInputsModalClosed
+  } = props;
+  const {
+    rule,
+    objects
+  } = selectedRule;
+  const {
+    userInputPrompts
+  } = rule;
+  const getTypeOfInput = (key, prompts) => {
+    var _prompts$find;
+    return (_prompts$find = prompts.find(({
+      variableName
+    }) => variableName === key)) === null || _prompts$find === void 0 ? void 0 : _prompts$find.inputType;
+  };
+  const generateInputValue = (inputType, data) => {
+    switch (inputType) {
+      case UserInputType.DROPDOWN:
+        return {
+          inputType,
+          value: data ? data.value : ''
+        };
+      case UserInputType.NUMBER:
+        return {
+          inputType,
+          value: Number(data)
+        };
+      default:
+        return {
+          inputType,
+          value: data
+        };
+    }
+  };
+  const handleSubmit = data => {
+    const output = Object.entries(data).reduce((acc, [key, value]) => {
+      const inputType = getTypeOfInput(key, userInputPrompts);
+      if (!inputType) {
+        return acc;
+      }
+      acc[key] = generateInputValue(inputType, value);
+      return acc;
+    }, {});
+    return invokeRule(rule.id, objects, output);
+  };
+  const handleOpen = () => {
+    if (onInputsModalOpened) {
+      onInputsModalOpened();
+    }
+  };
+  const handleClose = () => {
+    clearSelectedRule();
+    if (onInputsModalClosed) {
+      onInputsModalClosed();
+    }
+  };
+  const generateUserInputForm = inputPrompt => {
+    switch (inputPrompt.inputType) {
+      case UserInputType.TEXT:
+        return /*#__PURE__*/React.createElement(TextInputPrompt, {
+          key: inputPrompt.variableName,
+          userInputPrompt: inputPrompt
+        });
+      case UserInputType.NUMBER:
+        return /*#__PURE__*/React.createElement(NumberInputPrompt, {
+          key: inputPrompt.variableName,
+          userInputPrompt: inputPrompt
+        });
+      case UserInputType.DROPDOWN:
+        return /*#__PURE__*/React.createElement(SelectInputPrompt, {
+          key: inputPrompt.variableName,
+          userInputPrompt: inputPrompt
+        });
+      case UserInputType.BOOLEAN:
+        return /*#__PURE__*/React.createElement(BooleanInputPrompt, {
+          key: inputPrompt.variableName,
+          userInputPrompt: inputPrompt
+        });
+      case UserInputType.PARAGRAPH:
+        return /*#__PURE__*/React.createElement(ParagraphInputPrompt, {
+          key: inputPrompt.variableName,
+          userInputPrompt: inputPrompt
+        });
+      default:
+        return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("br", null), /*#__PURE__*/React.createElement(ErrorMessage, null, messages.errorInputTypeIsNotSupported.defaultMessage), /*#__PURE__*/React.createElement("br", null));
+    }
+  };
+  return /*#__PURE__*/React.createElement(Modal, {
+    "data-testid": "automation-platform.ui.manual-rules-container.manual-triggers-form.modal",
+    onClose: handleClose,
+    onOpenComplete: handleOpen
+  }, /*#__PURE__*/React.createElement(Form, {
+    onSubmit: handleSubmit
+  }, ({
+    formProps,
+    submitting
+  }) => /*#__PURE__*/React.createElement("form", formProps, /*#__PURE__*/React.createElement(ModalHeader, null, /*#__PURE__*/React.createElement(ModalTitle, null, rule.name)), /*#__PURE__*/React.createElement(ModalBody, null, messages.inputRequiredForAction.defaultMessage, /*#__PURE__*/React.createElement(FormSection, null, userInputPrompts.map(generateUserInputForm))), /*#__PURE__*/React.createElement(ModalFooter, null, /*#__PURE__*/React.createElement(Button, {
+    appearance: "subtle",
+    onClick: handleClose,
+    isDisabled: submitting
+  }, messages.cancelButtonTitle.defaultMessage), /*#__PURE__*/React.createElement(Button, {
+    appearance: "primary",
+    type: "submit",
+    isLoading: submitting,
+    autoFocus: true
+  }, messages.continueButtonTitle.defaultMessage)))));
+};
+export default UserInputForm;

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

@@ -0,0 +1,52 @@
+import React from 'react';
+import { di } from 'react-magnetic-di';
+import { ErrorMessage, Field } from '@atlaskit/form';
+import Textfield from '@atlaskit/textfield';
+import messages from '../../common/messages';
+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
+}) => {
+  const {
+    variableName,
+    required,
+    displayName,
+    defaultValue
+  } = userInputPrompt;
+  const generateErrorMessage = error => {
+    switch (error) {
+      case Errors.EMPTY:
+        return /*#__PURE__*/React.createElement(ErrorMessage, null, messages.errorInputMustNotBeEmpty.defaultMessage);
+      case Errors.INVALID_NUMBER:
+        return /*#__PURE__*/React.createElement(ErrorMessage, null, messages.errorValueIsNotValidNumber.defaultMessage);
+      default:
+        return null;
+    }
+  };
+  return /*#__PURE__*/React.createElement(Field, {
+    key: variableName,
+    "aria-required": required,
+    name: variableName,
+    label: displayName,
+    defaultValue: defaultValue,
+    isRequired: required,
+    validate: value => numberValidate(required, value)
+  }, ({
+    fieldProps,
+    error
+  }) => /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Textfield, fieldProps), generateErrorMessage(error)));
+};
+export default NumberInputPrompt;

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

@@ -0,0 +1,44 @@
+import React from 'react';
+import { di } from 'react-magnetic-di';
+import { ErrorMessage, Field } from '@atlaskit/form';
+import TextArea from '@atlaskit/textarea';
+import messages from '../../common/messages';
+var Errors = /*#__PURE__*/function (Errors) {
+  Errors["EMPTY"] = "EMPTY";
+  Errors["CHARACTER_LIMIT"] = "CHARACTER_LIMIT";
+  return Errors;
+}(Errors || {});
+const MAX_PARAGRAPH_CHARACTER_LIMIT = 5000;
+const ParagraphInputPrompt = ({
+  userInputPrompt
+}) => {
+  const {
+    variableName,
+    required,
+    displayName,
+    defaultValue
+  } = userInputPrompt;
+  const validate = value => {
+    if (required && !value) {
+      return Errors.EMPTY;
+    }
+    if (value && (value === null || value === void 0 ? void 0 : value.trim().length) === 0) {
+      return Errors.EMPTY;
+    }
+    if (value && value.length > MAX_PARAGRAPH_CHARACTER_LIMIT) {
+      return Errors.CHARACTER_LIMIT;
+    }
+    return undefined;
+  };
+  return /*#__PURE__*/React.createElement(Field, {
+    name: variableName,
+    label: displayName,
+    defaultValue: defaultValue,
+    isRequired: required,
+    validate: validate
+  }, ({
+    fieldProps,
+    error
+  }) => /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(TextArea, fieldProps), error === Errors.EMPTY && /*#__PURE__*/React.createElement(ErrorMessage, null, messages.errorInputMustNotBeEmpty.defaultMessage), error === Errors.CHARACTER_LIMIT && /*#__PURE__*/React.createElement(ErrorMessage, null, messages.errorInputCharacterLimitReached.defaultMessage)));
+};
+export default ParagraphInputPrompt;

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

@@ -0,0 +1,45 @@
+import _extends from "@babel/runtime/helpers/extends";
+import React from 'react';
+import { di } from 'react-magnetic-di';
+import { ErrorMessage, Field } from '@atlaskit/form';
+import Select from '@atlaskit/select';
+import messages from '../../common/messages';
+var Errors = /*#__PURE__*/function (Errors) {
+  Errors["EMPTY"] = "EMPTY";
+  return Errors;
+}(Errors || {});
+const SelectInputPrompt = ({
+  userInputPrompt
+}) => {
+  const {
+    variableName,
+    required,
+    displayName,
+    defaultValue
+  } = userInputPrompt;
+  const validate = value => {
+    if (required && !value) {
+      return Errors.EMPTY;
+    }
+    return undefined;
+  };
+  const selectOptions = defaultValue.map(value => ({
+    label: value,
+    value
+  }));
+  return /*#__PURE__*/React.createElement(Field, {
+    name: variableName,
+    label: displayName,
+    isRequired: required,
+    validate: validate
+  }, ({
+    fieldProps,
+    error
+  }) => /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Select, _extends({
+    isClearable: true,
+    isSearchable: true,
+    options: selectOptions,
+    menuPosition: "fixed"
+  }, fieldProps)), error === Errors.EMPTY && /*#__PURE__*/React.createElement(ErrorMessage, null, messages.errorInputMustNotBeEmpty.defaultMessage)));
+};
+export default SelectInputPrompt;

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

@@ -0,0 +1,31 @@
+import React from 'react';
+import { di } from 'react-magnetic-di';
+import { ErrorMessage, Field } from '@atlaskit/form';
+import Textfield from '@atlaskit/textfield';
+import messages from '../../common/messages';
+var Errors = /*#__PURE__*/function (Errors) {
+  Errors["EMPTY"] = "EMPTY";
+  return Errors;
+}(Errors || {});
+const TextInputPrompt = ({
+  userInputPrompt
+}) => {
+  const {
+    variableName,
+    required,
+    displayName,
+    defaultValue
+  } = userInputPrompt;
+  const validate = value => required && !value ? Errors.EMPTY : undefined;
+  return /*#__PURE__*/React.createElement(Field, {
+    name: variableName,
+    label: displayName,
+    defaultValue: defaultValue,
+    isRequired: required,
+    validate: validate
+  }, ({
+    fieldProps,
+    error
+  }) => /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Textfield, fieldProps), error === Errors.EMPTY && /*#__PURE__*/React.createElement(ErrorMessage, null, messages.errorInputMustNotBeEmpty.defaultMessage)));
+};
+export default TextInputPrompt;

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

@@ -0,0 +1,53 @@
+import { getInvocationUrl, getSearchUrl, performPostRequest } from './../common/utils';
+
+/**
+ * Manual trigger rules API fetch. Fetches a list of manually triggered rules according to the context provided
+ * in env, and query.
+ * @param env - The environment to look up rules against
+ * @param query - the workspace/container/objects to fetch rules against
+ */
+export const searchManuallyTriggeredRules = async (env, site, query) => {
+  const url = await getSearchUrl(env, 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.reduce((acc, {
+    id,
+    name,
+    ruleScope,
+    userInputs
+  }) => ({
+    // eslint-disable-next-line
+    ...acc,
+    [id]: {
+      id,
+      name,
+      ruleScope,
+      userInputPrompts: userInputs
+    }
+  }), {});
+};
+
+/**
+ * Invoke a manually triggered rule via the API.
+ * @param env - the environment to use when invoking the rule
+ * @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 (env, site, ruleId, objects, userInputs) => {
+  const url = await getInvocationUrl(env, 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-modal/index.js

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,62 @@
+import React, { useEffect, useState } from 'react';
+import { useAnalyticsEvents } from '@atlaskit/analytics-next';
+import Modal, { ModalBody, ModalFooter } from '@atlaskit/modal-dialog';
+import { AutomationMenuContextContainer } from './menu-context';
+import { AutomationModalBody } from './sub-components/body';
+import { AutomationModalFooter } from './sub-components/footer';
+import { AutomationModalHeader } from './sub-components/header';
+export const AutomationModal = ({
+  environment,
+  baseAutomationUrl,
+  siteAri,
+  objectAri,
+  canManageAutomation,
+  onClose,
+  onCloseComplete,
+  modalTitle,
+  modalDescription,
+  emptyStateDescription,
+  emptyStateAdminDescription,
+  analyticsSource
+}) => {
+  const {
+    createAnalyticsEvent
+  } = useAnalyticsEvents();
+  const [selectedRule, setSelectedRule] = useState();
+  useEffect(() => {
+    createAnalyticsEvent({
+      type: 'sendScreenEvent',
+      data: {
+        name: analyticsSource
+      }
+    }).fire();
+  }, [createAnalyticsEvent, analyticsSource]);
+  return /*#__PURE__*/React.createElement(AutomationMenuContextContainer, {
+    environment: environment,
+    baseAutomationUrl: baseAutomationUrl,
+    objectAri: objectAri,
+    siteAri: siteAri,
+    canManageAutomation: canManageAutomation,
+    analyticsSource: analyticsSource,
+    emptyStateDescription: emptyStateDescription,
+    emptyStateAdminDescription: emptyStateAdminDescription,
+    onRuleInvocationLifecycleDone: onClose
+  }, () => {
+    return /*#__PURE__*/React.createElement(Modal, {
+      onClose: onClose,
+      onCloseComplete: onCloseComplete,
+      width: 600,
+      height: 480,
+      testId: "smart-card-automation-action-modal"
+    }, /*#__PURE__*/React.createElement(AutomationModalHeader, {
+      modalTitle: modalTitle,
+      modalDescription: modalDescription
+    }), /*#__PURE__*/React.createElement(ModalBody, null, /*#__PURE__*/React.createElement(AutomationModalBody, {
+      selectedRule: selectedRule,
+      setSelectedRule: setSelectedRule
+    })), /*#__PURE__*/React.createElement(ModalFooter, null, /*#__PURE__*/React.createElement(AutomationModalFooter, {
+      selectedRule: selectedRule,
+      onClose: onClose
+    })));
+  });
+};

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

@@ -0,0 +1 @@
+export { AutomationMenuContextContainer, useAutomationMenu } from './main';

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

@@ -0,0 +1,61 @@
+// 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, { createContext, useContext } from 'react';
+import { ManualRulesContainer } from '../../manual-triggers-container';
+const AutomationMenuContext = /*#__PURE__*/createContext(undefined);
+const AutomationMenuProvider = ({
+  children,
+  value
+}) => {
+  return /*#__PURE__*/React.createElement(AutomationMenuContext.Provider, {
+    value: value
+  }, children);
+};
+
+// Hook that can be used anywhere under the AutomationMenuContextContainer to access the AutomationMenuContext values
+export const useAutomationMenu = () => {
+  const context = useContext(AutomationMenuContext);
+  if (context === undefined) {
+    throw new Error('useAutomationMenu must be used within a AutomationMenuProvider');
+  }
+  return context;
+};
+export const AutomationMenuContextContainer = ({
+  environment,
+  baseAutomationUrl,
+  analyticsSource,
+  objectAri,
+  siteAri,
+  canManageAutomation,
+  children,
+  emptyStateDescription,
+  emptyStateAdminDescription,
+  onRuleInvocationSuccess,
+  onRuleInvocationFailure,
+  onRuleInvocationLifecycleDone
+}) => {
+  return /*#__PURE__*/React.createElement(ManualRulesContainer, {
+    env: environment,
+    site: siteAri,
+    query: {
+      objects: [objectAri]
+    },
+    onRuleInvocationLifecycleDone: onRuleInvocationLifecycleDone,
+    onRuleInvocationSuccess: onRuleInvocationSuccess,
+    onRuleInvocationFailure: onRuleInvocationFailure
+  }, props => {
+    const contextValue = {
+      ...props,
+      analyticsSource,
+      objectAri,
+      baseAutomationUrl,
+      canManageAutomation,
+      emptyStateDescription,
+      emptyStateAdminDescription
+    };
+    return /*#__PURE__*/React.createElement(AutomationMenuProvider, {
+      value: contextValue
+    }, children());
+  });
+};

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

@@ -0,0 +1,2 @@
+import { AutomationModalBody } from './main';
+export { AutomationModalBody };