@atlaskit/smart-card 26.69.1 → 26.71.0

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

@@ -0,0 +1,240 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+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 var useManualRules = function useManualRules(env, site, query) {
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    initialised = _useState2[0],
+    setInitialised = _useState2[1];
+  var _useState3 = useState(null),
+    _useState4 = _slicedToArray(_useState3, 2),
+    error = _useState4[0],
+    setError = _useState4[1];
+  var _useState5 = useState([]),
+    _useState6 = _slicedToArray(_useState5, 2),
+    rules = _useState6[0],
+    setRules = _useState6[1];
+  var transformRules = function transformRules(ruleResponse) {
+    var rulesUnsorted = Object.values(ruleResponse);
+    return rulesUnsorted.sort(function (rule1, rule2) {
+      return rule1.name.localeCompare(rule2.name);
+    });
+  };
+  var triggerFetch = /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var fetchedRules;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            setInitialised(false);
+            _context.prev = 1;
+            _context.next = 4;
+            return searchManuallyTriggeredRules(env, site, query);
+          case 4:
+            fetchedRules = _context.sent;
+            setError(null);
+            setRules(transformRules(fetchedRules));
+            _context.next = 13;
+            break;
+          case 9:
+            _context.prev = 9;
+            _context.t0 = _context["catch"](1);
+            setError(_context.t0);
+            setRules([]);
+          case 13:
+            _context.prev = 13;
+            setInitialised(true);
+            return _context.finish(13);
+          case 16:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[1, 9, 13, 16]]);
+    }));
+    return function triggerFetch() {
+      return _ref.apply(this, arguments);
+    };
+  }();
+  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 var ManualRulesContainer = function ManualRulesContainer(props) {
+  var env = props.env,
+    site = props.site,
+    query = props.query,
+    children = props.children,
+    onInputsModalOpened = props.onInputsModalOpened,
+    onInputsModalClosed = props.onInputsModalClosed,
+    onRuleInvocationLifecycleStarted = props.onRuleInvocationLifecycleStarted,
+    onRuleInvocationSuccess = props.onRuleInvocationSuccess,
+    onRuleInvocationFailure = props.onRuleInvocationFailure,
+    onRuleInvocationLifecycleDone = props.onRuleInvocationLifecycleDone;
+  // Initial data loading state
+  var _useManualRules = useManualRules(env, site, query),
+    _useManualRules2 = _slicedToArray(_useManualRules, 4),
+    triggerFetch = _useManualRules2[0],
+    initialised = _useManualRules2[1],
+    error = _useManualRules2[2],
+    rules = _useManualRules2[3];
+  // 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.
+  var _useState7 = useState(null),
+    _useState8 = _slicedToArray(_useState7, 2),
+    selectedRule = _useState8[0],
+    setSelectedRule = _useState8[1];
+  var clearSelectedRule = function clearSelectedRule() {
+    setSelectedRule(null);
+  };
+  // Value set when a rule is invoking, either from the dialog or without dialog
+  var _useState9 = useState(null),
+    _useState10 = _slicedToArray(_useState9, 2),
+    invokingRuleId = _useState10[0],
+    setInvokingRuleId = _useState10[1];
+
+  // Memoized projection of rules by id
+  var rulesById = useMemo(function () {
+    return rules.reduce(function (acc, rule) {
+      return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, rule.id, rule));
+    }, {});
+  }, [rules]);
+  var getRule = function getRule(id) {
+    return rulesById[id];
+  };
+  var ruleHasInputs = function ruleHasInputs(rule) {
+    var _rule$userInputPrompt;
+    return (rule === null || rule === void 0 || (_rule$userInputPrompt = rule.userInputPrompts) === null || _rule$userInputPrompt === void 0 ? void 0 : _rule$userInputPrompt.length) > 0;
+  };
+  var getFailedObjects = function getFailedObjects(response) {
+    return Object.keys(response).filter(function (object) {
+      return response[object] !== 'SUCCESS';
+    });
+  };
+  var getSuccessfulObjects = function getSuccessfulObjects(response) {
+    return Object.keys(response).filter(function (object) {
+      return response[object] === 'SUCCESS';
+    });
+  };
+  var handleInvocationFailure = function handleInvocationFailure(ruleId, successfulObjects, failedObjects) {
+    if (onRuleInvocationFailure) {
+      onRuleInvocationFailure(ruleId, successfulObjects, failedObjects);
+    }
+  };
+  var invokeRule = /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(ruleId, objects, userInputs) {
+      var rule, response, _failedObjects, successfulObjects;
+      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            rule = getRule(ruleId);
+            if (!rule) {
+              _context2.next = 19;
+              break;
+            }
+            setInvokingRuleId(ruleId);
+            _context2.prev = 3;
+            if (onRuleInvocationLifecycleStarted) {
+              onRuleInvocationLifecycleStarted(ruleId, objects, userInputs);
+            }
+            _context2.next = 7;
+            return invokeManuallyTriggeredRule(env, site, ruleId, objects, userInputs);
+          case 7:
+            response = _context2.sent;
+            _failedObjects = getFailedObjects(response);
+            setInvokingRuleId(null);
+            if (_failedObjects.length === 0) {
+              if (onRuleInvocationSuccess) {
+                onRuleInvocationSuccess(ruleId, objects);
+              }
+            } else {
+              successfulObjects = getSuccessfulObjects(response);
+              handleInvocationFailure(ruleId, successfulObjects, _failedObjects);
+            }
+            _context2.next = 17;
+            break;
+          case 13:
+            _context2.prev = 13;
+            _context2.t0 = _context2["catch"](3);
+            handleInvocationFailure(ruleId, [], objects);
+            setInvokingRuleId(null);
+          case 17:
+            _context2.next = 20;
+            break;
+          case 19:
+            handleInvocationFailure(ruleId, [], objects);
+          case 20:
+            clearSelectedRule();
+            if (onRuleInvocationLifecycleDone) {
+              onRuleInvocationLifecycleDone(ruleId, objects);
+            }
+          case 22:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, null, [[3, 13]]);
+    }));
+    return function invokeRule(_x, _x2, _x3) {
+      return _ref2.apply(this, arguments);
+    };
+  }();
+  var invokeRuleOrShowDialog = function invokeRuleOrShowDialog(ruleId, objects) {
+    var rule = getRule(ruleId);
+    if (!rule) {
+      return handleInvocationFailure(ruleId, [], objects);
+    }
+    if (ruleHasInputs(rule)) {
+      setSelectedRule({
+        rule: rule,
+        objects: objects
+      });
+    } else {
+      invokeRule(ruleId, objects);
+    }
+  };
+  return /*#__PURE__*/React.createElement(React.Fragment, null, children({
+    triggerFetch: triggerFetch,
+    initialised: initialised,
+    error: error,
+    rules: rules,
+    invokingRuleId: invokingRuleId,
+    invokeRuleOrShowDialog: invokeRuleOrShowDialog
+  }), /*#__PURE__*/React.createElement(ModalTransition, null, selectedRule && /*#__PURE__*/React.createElement(UserInputForm, {
+    onInputsModalOpened: onInputsModalOpened,
+    onInputsModalClosed: onInputsModalClosed,
+    clearSelectedRule: clearSelectedRule,
+    selectedRule: selectedRule,
+    invokeRule: invokeRule
+  })));
+};

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

@@ -0,0 +1,21 @@
+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';
+var BooleanInputPrompt = function BooleanInputPrompt(_ref) {
+  var userInputPrompt = _ref.userInputPrompt;
+  var variableName = userInputPrompt.variableName,
+    displayName = userInputPrompt.displayName,
+    defaultValue = userInputPrompt.defaultValue;
+  return /*#__PURE__*/React.createElement(CheckboxField, {
+    name: variableName,
+    defaultIsChecked: defaultValue || false
+  }, function (_ref2) {
+    var fieldProps = _ref2.fieldProps;
+    return /*#__PURE__*/React.createElement(Checkbox, _extends({}, fieldProps, {
+      label: displayName
+    }));
+  });
+};
+export default BooleanInputPrompt;

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

@@ -0,0 +1,126 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+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';
+var UserInputForm = function UserInputForm(props) {
+  var selectedRule = props.selectedRule,
+    clearSelectedRule = props.clearSelectedRule,
+    invokeRule = props.invokeRule,
+    onInputsModalOpened = props.onInputsModalOpened,
+    onInputsModalClosed = props.onInputsModalClosed;
+  var rule = selectedRule.rule,
+    objects = selectedRule.objects;
+  var userInputPrompts = rule.userInputPrompts;
+  var getTypeOfInput = function getTypeOfInput(key, prompts) {
+    var _prompts$find;
+    return (_prompts$find = prompts.find(function (_ref) {
+      var variableName = _ref.variableName;
+      return variableName === key;
+    })) === null || _prompts$find === void 0 ? void 0 : _prompts$find.inputType;
+  };
+  var generateInputValue = function generateInputValue(inputType, data) {
+    switch (inputType) {
+      case UserInputType.DROPDOWN:
+        return {
+          inputType: inputType,
+          value: data ? data.value : ''
+        };
+      case UserInputType.NUMBER:
+        return {
+          inputType: inputType,
+          value: Number(data)
+        };
+      default:
+        return {
+          inputType: inputType,
+          value: data
+        };
+    }
+  };
+  var handleSubmit = function handleSubmit(data) {
+    var output = Object.entries(data).reduce(function (acc, _ref2) {
+      var _ref3 = _slicedToArray(_ref2, 2),
+        key = _ref3[0],
+        value = _ref3[1];
+      var inputType = getTypeOfInput(key, userInputPrompts);
+      if (!inputType) {
+        return acc;
+      }
+      acc[key] = generateInputValue(inputType, value);
+      return acc;
+    }, {});
+    return invokeRule(rule.id, objects, output);
+  };
+  var handleOpen = function handleOpen() {
+    if (onInputsModalOpened) {
+      onInputsModalOpened();
+    }
+  };
+  var handleClose = function handleClose() {
+    clearSelectedRule();
+    if (onInputsModalClosed) {
+      onInputsModalClosed();
+    }
+  };
+  var generateUserInputForm = function 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
+  }, function (_ref4) {
+    var formProps = _ref4.formProps,
+      submitting = _ref4.submitting;
+    return /*#__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/esm/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 var Errors = /*#__PURE__*/function (Errors) {
+  Errors["EMPTY"] = "EMPTY";
+  Errors["INVALID_NUMBER"] = "INVALID_NUMBER";
+  return Errors;
+}({});
+export var numberValidate = function numberValidate(isRequired, value) {
+  if (isRequired && !value) {
+    return Errors.EMPTY;
+  }
+  if (value && Number.isNaN(Number(value))) {
+    return Errors.INVALID_NUMBER;
+  }
+  return undefined;
+};
+var NumberInputPrompt = function NumberInputPrompt(_ref) {
+  var userInputPrompt = _ref.userInputPrompt;
+  var variableName = userInputPrompt.variableName,
+    required = userInputPrompt.required,
+    displayName = userInputPrompt.displayName,
+    defaultValue = userInputPrompt.defaultValue;
+  var generateErrorMessage = function 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: function validate(value) {
+      return numberValidate(required, value);
+    }
+  }, function (_ref2) {
+    var fieldProps = _ref2.fieldProps,
+      error = _ref2.error;
+    return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Textfield, fieldProps), generateErrorMessage(error));
+  });
+};
+export default NumberInputPrompt;

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

@@ -0,0 +1,42 @@
+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 || {});
+var MAX_PARAGRAPH_CHARACTER_LIMIT = 5000;
+var ParagraphInputPrompt = function ParagraphInputPrompt(_ref) {
+  var userInputPrompt = _ref.userInputPrompt;
+  var variableName = userInputPrompt.variableName,
+    required = userInputPrompt.required,
+    displayName = userInputPrompt.displayName,
+    defaultValue = userInputPrompt.defaultValue;
+  var validate = function 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
+  }, function (_ref2) {
+    var fieldProps = _ref2.fieldProps,
+      error = _ref2.error;
+    return /*#__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/esm/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 || {});
+var SelectInputPrompt = function SelectInputPrompt(_ref) {
+  var userInputPrompt = _ref.userInputPrompt;
+  var variableName = userInputPrompt.variableName,
+    required = userInputPrompt.required,
+    displayName = userInputPrompt.displayName,
+    defaultValue = userInputPrompt.defaultValue;
+  var validate = function validate(value) {
+    if (required && !value) {
+      return Errors.EMPTY;
+    }
+    return undefined;
+  };
+  var selectOptions = defaultValue.map(function (value) {
+    return {
+      label: value,
+      value: value
+    };
+  });
+  return /*#__PURE__*/React.createElement(Field, {
+    name: variableName,
+    label: displayName,
+    isRequired: required,
+    validate: validate
+  }, function (_ref2) {
+    var fieldProps = _ref2.fieldProps,
+      error = _ref2.error;
+    return /*#__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/esm/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 || {});
+var TextInputPrompt = function TextInputPrompt(_ref) {
+  var userInputPrompt = _ref.userInputPrompt;
+  var variableName = userInputPrompt.variableName,
+    required = userInputPrompt.required,
+    displayName = userInputPrompt.displayName,
+    defaultValue = userInputPrompt.defaultValue;
+  var validate = function validate(value) {
+    return required && !value ? Errors.EMPTY : undefined;
+  };
+  return /*#__PURE__*/React.createElement(Field, {
+    name: variableName,
+    label: displayName,
+    defaultValue: defaultValue,
+    isRequired: required,
+    validate: validate
+  }, function (_ref2) {
+    var fieldProps = _ref2.fieldProps,
+      error = _ref2.error;
+    return /*#__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/esm/view/FlexibleCard/components/actions/automation-action/automation-manual-triggers/manual-triggers-container/services/index.js

@@ -0,0 +1,89 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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 var searchManuallyTriggeredRules = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(env, site, query) {
+    var url, response;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return getSearchUrl(env, site);
+        case 2:
+          url = _context.sent;
+          _context.next = 5;
+          return performPostRequest(url, {
+            body: JSON.stringify(query)
+          });
+        case 5:
+          response = _context.sent;
+          return _context.abrupt("return", response.reduce(function (acc, _ref2) {
+            var id = _ref2.id,
+              name = _ref2.name,
+              ruleScope = _ref2.ruleScope,
+              userInputs = _ref2.userInputs;
+            return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, id, {
+              id: id,
+              name: name,
+              ruleScope: ruleScope,
+              userInputPrompts: userInputs
+            }));
+          }, {}));
+        case 7:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function searchManuallyTriggeredRules(_x, _x2, _x3) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+/**
+ * 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 var invokeManuallyTriggeredRule = /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(env, site, ruleId, objects, userInputs) {
+    var url, bodyRaw;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _context2.next = 2;
+          return getInvocationUrl(env, site, ruleId);
+        case 2:
+          url = _context2.sent;
+          bodyRaw = {
+            objects: objects
+          };
+          if (userInputs) {
+            bodyRaw.userInputs = userInputs;
+          }
+          return _context2.abrupt("return", performPostRequest(url, {
+            body: JSON.stringify(bodyRaw)
+          }));
+        case 6:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return function invokeManuallyTriggeredRule(_x4, _x5, _x6, _x7, _x8) {
+    return _ref3.apply(this, arguments);
+  };
+}();

package/dist/esm/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;