@atlaskit/smart-card 26.69.1 → 26.70.0

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

@@ -0,0 +1,65 @@
+import React from 'react';
+import { useAnalyticsEvents } from '@atlaskit/analytics-next';
+import { ButtonItem } from '@atlaskit/menu';
+import { Box, Stack, xcss } from '@atlaskit/primitives';
+import Spinner from '@atlaskit/spinner';
+import { useAutomationMenu } from '../../menu-context';
+const ruleButtonStyle = xcss({
+  borderColor: 'color.border',
+  borderStyle: 'solid',
+  borderWidth: 'border.width',
+  borderRadius: 'border.radius'
+});
+const selectedRuleButtonStyle = xcss({
+  backgroundColor: 'color.background.accent.blue.subtlest',
+  borderColor: 'color.border.accent.blue',
+  borderStyle: 'solid',
+  borderWidth: 'border.width.outline',
+  borderRadius: 'border.radius'
+});
+const ruleNameStyle = xcss({
+  // Using this to increase the height of the button itself.
+  height: '28px'
+});
+export const AutomationModalRule = ({
+  rule,
+  selectedRule,
+  setSelectedRule
+}) => {
+  const {
+    createAnalyticsEvent
+  } = useAnalyticsEvents();
+  const {
+    analyticsSource,
+    invokingRuleId
+  } = useAutomationMenu();
+  const isSelectedRule = (selectedRule === null || selectedRule === void 0 ? void 0 : selectedRule.id) === rule.id;
+  const isExecuting = rule.id === invokingRuleId;
+  const ruleOnClick = () => {
+    createAnalyticsEvent({
+      type: 'sendUIEvent',
+      data: {
+        action: 'clicked',
+        actionSubject: 'button',
+        actionSubjectId: 'selectManualTriggerAutomation',
+        source: analyticsSource,
+        attributes: {
+          ruleId: rule.id.toString()
+        }
+      }
+    }).fire();
+    setSelectedRule(rule);
+  };
+  return /*#__PURE__*/React.createElement(Box, {
+    xcss: isSelectedRule ? selectedRuleButtonStyle : ruleButtonStyle
+  }, /*#__PURE__*/React.createElement(ButtonItem, {
+    isDisabled: !!invokingRuleId,
+    iconBefore: isExecuting ? /*#__PURE__*/React.createElement(Spinner, {
+      size: "small"
+    }) : null,
+    onClick: ruleOnClick
+  }, /*#__PURE__*/React.createElement(Stack, {
+    xcss: ruleNameStyle,
+    alignBlock: "center"
+  }, rule.name)));
+};

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

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

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

@@ -0,0 +1,25 @@
+import React from 'react';
+import { MenuGroup } from '@atlaskit/menu';
+import { Stack } from '@atlaskit/primitives';
+import { useAutomationMenu } from '../../menu-context';
+import { AutomationModalEmptyState } from '../empty-state';
+import { AutomationModalRule } from '../rule';
+export const AutomationModalRuleList = ({
+  selectedRule,
+  setSelectedRule
+}) => {
+  const {
+    rules
+  } = useAutomationMenu();
+  if (rules.length === 0) {
+    return /*#__PURE__*/React.createElement(AutomationModalEmptyState, null);
+  }
+  return /*#__PURE__*/React.createElement(MenuGroup, null, /*#__PURE__*/React.createElement(Stack, {
+    space: "space.050"
+  }, rules.map(rule => /*#__PURE__*/React.createElement(AutomationModalRule, {
+    key: `manual-rule-${rule.id}`,
+    rule: rule,
+    selectedRule: selectedRule,
+    setSelectedRule: setSelectedRule
+  }))));
+};

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

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

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

@@ -0,0 +1,79 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import { keyframes, css } from '@emotion/react';
+import { N20, N30 } from '@atlaskit/theme/colors';
+const AutomationSkeletonContainer = css({
+  paddingBlock: "var(--ds-space-025, 2px)"
+});
+const SkeletonContainer = css({
+  marginBlock: "var(--ds-space-100, 8px)",
+  marginInline: "var(--ds-space-250, 20px)",
+  display: 'flex'
+});
+const SkeletonIcon = css({
+  width: "var(--ds-space-200, 16px)",
+  height: "var(--ds-space-200, 16px)",
+  display: 'inline-block',
+  borderRadius: "var(--ds-space-025, 2px)",
+  backgroundColor: 'currentColor',
+  border: `${"var(--ds-space-025, 2px)"} solid transparent`,
+  opacity: 0.15
+});
+const MenuIcon = css({
+  width: '24px',
+  height: '24px',
+  display: 'flex',
+  justifyContent: 'center',
+  alignItems: 'center'
+});
+const shimmer = keyframes({
+  '0%': {
+    backgroundPosition: '-300px 0'
+  },
+  '100%': {
+    backgroundPosition: '2000px 0'
+  }
+});
+const SkeletonText = css({
+  width: '85%',
+  height: "var(--ds-space-200, 16px)",
+  marginTop: "var(--ds-space-050, 4px)",
+  marginLeft: "var(--ds-space-150, 12px)",
+  animationDuration: '1s',
+  animationFillMode: 'forwards',
+  animationIterationCount: 'infinite',
+  animationName: shimmer,
+  animationTimingFunction: 'linear',
+  backgroundColor: `var(--ds-skeleton, ${N30})`,
+  backgroundImage: `linear-gradient(to right, ${`var(--ds-skeleton, ${N30})`} 10%, ${`var(--ds-skeleton-subtle, ${N20})`} 30%, ${`var(--ds-skeleton, ${N30})`} 50%)`,
+  backgroundRepeat: 'no-repeat'
+});
+const SkeletonLine = () => jsx("div", {
+  css: SkeletonContainer
+}, jsx("div", {
+  css: MenuIcon
+}, jsx("div", {
+  css: SkeletonIcon
+})), jsx("div", {
+  css: SkeletonText
+}));
+const getSkeletonLines = lineCount => {
+  const skeletonLines = [];
+  for (let i = 0; i < lineCount; i++) {
+    skeletonLines.push(jsx(SkeletonLine, {
+      key: `skeleton-line-${i}`
+    }));
+  }
+  return skeletonLines;
+};
+export const Skeleton = props => {
+  const {
+    lineCount = 5
+  } = props;
+  return (
+    // eslint-disable-next-line @atlaskit/design-system/use-primitives
+    jsx("div", {
+      css: AutomationSkeletonContainer
+    }, getSkeletonLines(lineCount))
+  );
+};

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

@@ -1,33 +1,56 @@
 import _extends from "@babel/runtime/helpers/extends";
-import React, { useState } from 'react';
+import React, { useState, lazy, Suspense } from 'react';
 import { FormattedMessage, useIntl } from 'react-intl-next';
 import AutomationManualTriggersGlyph from './manaul-triggers-icon';
 import Action from '../action';
 import { useFlexibleUiContext } from '../../../../../state/flexible-ui-context';
 import { ActionName } from '../../../../../constants';
 import { messages } from '../../../../../messages';
-// import { useSmartLinkContext } from '../../../../../../../link-provider/src';
-
+import { useSmartLinkContext } from '@atlaskit/link-provider';
+const AutomationModal = /*#__PURE__*/lazy(() => import( /* webpackChunkName: "@atlaskit-internal_smart-card-automation-modal" */'./automation-manual-triggers/manual-triggers-modal'));
 const handleAutomateActionClick = setIsModalOpen => {
   setIsModalOpen(true);
 };
+const handleAutomationActionClose = setIsModalOpen => {
+  setIsModalOpen(false);
+};
 const AutomationAction = props => {
-  var _context$actions;
-  const [_isModalOpen, setIsModalOpen] = useState(false);
+  var _ref, _context$actions;
+  const [isModalOpen, setIsModalOpen] = useState(false);
   const {
     formatMessage
   } = useIntl();
-  // const { connections } = useSmartLinkContext();
-
-  // const env = connections.client.envKey ?? 'prod';
+  const smartLinkContext = useSmartLinkContext();
+  const {
+    connections
+  } = smartLinkContext;
+  const environment = (_ref = connections.client.envKey) !== null && _ref !== void 0 ? _ref : 'prod';
   const context = useFlexibleUiContext();
-  const data = context === null || context === void 0 ? void 0 : (_context$actions = context.actions) === null || _context$actions === void 0 ? void 0 : _context$actions[ActionName.AutomationAction];
-  if (!data) {
+  const automationActionData = context === null || context === void 0 ? void 0 : (_context$actions = context.actions) === null || _context$actions === void 0 ? void 0 : _context$actions[ActionName.AutomationAction];
+  if (!automationActionData) {
     return null;
   }
+  const {
+    baseAutomationUrl,
+    objectName,
+    objectAri,
+    siteAri,
+    canManageAutomation,
+    analyticsSource,
+    modalTitle,
+    modalDescription
+  } = automationActionData;
   const automationActionTitle = /*#__PURE__*/React.createElement(FormattedMessage, messages.automation_action_title);
   const automationActionTooltip = /*#__PURE__*/React.createElement(FormattedMessage, messages.automation_action_tooltip);
   const automationActionIconLabel = formatMessage(messages.automation_action_icon_label);
+  const automationModalTitle = /*#__PURE__*/React.createElement(FormattedMessage, modalTitle);
+  const automationModalDescription = /*#__PURE__*/React.createElement(FormattedMessage, _extends({}, modalDescription, {
+    values: {
+      name: objectName,
+      b: chunks => /*#__PURE__*/React.createElement("strong", null, chunks),
+      br: /*#__PURE__*/React.createElement("br", null)
+    }
+  }));
   return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Action, _extends({
     content: automationActionTitle,
     icon: /*#__PURE__*/React.createElement(AutomationManualTriggersGlyph, {
@@ -35,8 +58,23 @@ const AutomationAction = props => {
     }),
     testId: "smart-action-automation-action",
     tooltipMessage: automationActionTooltip
-  }, data, props, {
+  }, automationActionData, props, {
     onClick: () => handleAutomateActionClick(setIsModalOpen)
+  })), isModalOpen &&
+  /*#__PURE__*/
+  // TODO skeleton modal fallback
+  React.createElement(Suspense, {
+    fallback: false
+  }, /*#__PURE__*/React.createElement(AutomationModal, {
+    environment: environment,
+    baseAutomationUrl: baseAutomationUrl,
+    objectAri: objectAri,
+    siteAri: siteAri,
+    canManageAutomation: canManageAutomation,
+    analyticsSource: analyticsSource,
+    modalTitle: automationModalTitle,
+    modalDescription: automationModalDescription,
+    onClose: () => handleAutomationActionClose(setIsModalOpen)
   })));
 };
 export default AutomationAction;

package/dist/es2019/view/LinkUrl/index.js

@@ -7,7 +7,7 @@ import { useLinkWarningModal } from './LinkWarningModal/hooks/use-link-warning-m
 import LinkWarningModal from './LinkWarningModal';
 const PACKAGE_DATA = {
   packageName: "@atlaskit/smart-card",
-  packageVersion: "26.69.1",
+  packageVersion: "26.70.0",
   componentName: 'linkUrl'
 };
 const Link = withLinkClickedEvent('a');

package/dist/esm/extractors/flexible/actions/extract-automation-action.js

@@ -24,7 +24,7 @@ var getProductData = function getProductData(meta) {
   return ProductData === null || ProductData === void 0 || (_ProductData$product = ProductData[product]) === null || _ProductData$product === void 0 ? void 0 : _ProductData$product[resourceType];
 };
 export var extractAutomationAction = function extractAutomationAction(response) {
-  if (!getBooleanFF('platform.linking-platfom.smart-card.confluence.page.automation-action') || !response.data) {
+  if (!getBooleanFF('platform.linking-platfom.smart-card.confluence.page.automation-action_xcdoi') || !response.data) {
     return undefined;
   }
   var data = response.data;

package/dist/esm/messages.js

@@ -67,7 +67,7 @@ export var messages = defineMessages({
   },
   automation_action_title: {
     id: 'fabric.linking.automation-action.title',
-    defaultMessage: 'Run automation...',
+    defaultMessage: 'View automation rules...',
     description: 'The title of the button in a hover card to open an automation menu for a given SmartLink.'
   },
   automation_action_icon_label: {
@@ -77,7 +77,7 @@ export var messages = defineMessages({
   },
   automation_action_tooltip: {
     id: 'fabric.linking.automation-action.tooltip',
-    defaultMessage: 'Open an automation modal',
+    defaultMessage: 'Select an automation rule to run',
     description: 'The tooltip for the automation action indicating that a button will open an automation modal.'
   },
   automation_action_confluence_page_modal_title: {

package/dist/esm/utils/analytics/analytics.js

@@ -15,7 +15,7 @@ export var ANALYTICS_CHANNEL = 'media';
 export var context = {
   componentName: 'smart-cards',
   packageName: "@atlaskit/smart-card",
-  packageVersion: "26.69.1"
+  packageVersion: "26.70.0"
 };
 export var TrackQuickActionType = /*#__PURE__*/function (TrackQuickActionType) {
   TrackQuickActionType["StatusUpdate"] = "StatusUpdate";

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

@@ -0,0 +1,58 @@
+var messages = {
+  successFlag: {
+    id: 'automation-platform.common.success-flag',
+    defaultMessage: 'Your automation is in progress',
+    description: 'Text for a success flag when an automation rule has been triggered'
+  },
+  failureFlagTitle: {
+    id: 'automation-platform.common.failure-flag-title',
+    defaultMessage: 'Oops we ran into a problem',
+    description: 'Title for an error flag when an automation rule failed to be triggered'
+  },
+  failureFlagDescription: {
+    id: 'automation-platform.common.failure-flag-description',
+    defaultMessage: "There was a problem and we couldn't run the automation '{0}'",
+    description: 'Description for an error flag when an automation rule failed to be triggered'
+  },
+  partialFailureFlagDescription: {
+    id: 'automation-platform.common.partial-failure-flag-description',
+    defaultMessage: "Couldn't run the automation against issues {0}, please ensure you have permission to view these issues",
+    description: 'Description for an error flag when some issues failed to invoke because user does not have view permission'
+  },
+  errorInputMustNotBeEmpty: {
+    id: 'automation-platform.common.error-input-must-not-be-empty',
+    defaultMessage: 'Input must not be empty',
+    description: 'The error message to show the value of a required field is empty'
+  },
+  errorInputCharacterLimitReached: {
+    id: 'automation-platform.common.error-input-character-limit-reached',
+    defaultMessage: 'Provided value exceeds the character limit for the field.',
+    description: 'The error message to show that the character limit has been reached for the field'
+  },
+  inputRequiredForAction: {
+    id: 'automation-platform.common.input-required-for-action',
+    defaultMessage: 'Your input is required to complete this action',
+    description: 'The title of the modal for user inputs'
+  },
+  errorInputTypeIsNotSupported: {
+    id: 'automation-platform.common.error-input-type-is-not-supported',
+    defaultMessage: 'Input type not supported yet',
+    description: 'The error message to show when the type of user input is not recognised'
+  },
+  errorValueIsNotValidNumber: {
+    id: 'automation-platform.common.error-value-is-not-valid-number',
+    defaultMessage: 'The value is not a valid number',
+    description: 'The error message for when the type of user input is number but the value is not a valid number'
+  },
+  cancelButtonTitle: {
+    id: 'automation-platform.common.cancel-button-title',
+    defaultMessage: 'Cancel',
+    description: 'The cancel button title'
+  },
+  continueButtonTitle: {
+    id: 'automation-platform.common.continue-button-title',
+    defaultMessage: 'Continue',
+    description: 'The continue button title'
+  }
+};
+export default messages;

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

@@ -0,0 +1,71 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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 { UserInputType } from './types';
+var mockScope = {
+  resources: []
+};
+export var mockRules = [{
+  id: 0,
+  name: 'Test rule 0 (no inputs)',
+  ruleScope: mockScope,
+  userInputs: []
+}, {
+  id: 1,
+  name: 'Test rule 1 (has inputs)',
+  ruleScope: mockScope,
+  userInputs: [{
+    defaultValue: '',
+    displayName: 'Test user input',
+    inputType: UserInputType.TEXT,
+    required: false,
+    variableName: 'testUserInput'
+  }]
+}, {
+  id: 2,
+  name: 'Test rule 2 (has multiple inputs)',
+  ruleScope: mockScope,
+  userInputs: [{
+    defaultValue: '',
+    displayName: 'Text user input',
+    inputType: UserInputType.TEXT,
+    required: false,
+    variableName: 'textUserInput'
+  }, {
+    defaultValue: '',
+    displayName: 'Number user input',
+    inputType: UserInputType.NUMBER,
+    required: false,
+    variableName: 'numberUserInput'
+  }, {
+    defaultValue: true,
+    displayName: 'Boolean user input',
+    inputType: UserInputType.BOOLEAN,
+    required: false,
+    variableName: 'booleanUserInput'
+  }, {
+    defaultValue: [''],
+    displayName: 'Dropdown user input',
+    inputType: UserInputType.DROPDOWN,
+    required: false,
+    variableName: 'dropdownUserInput'
+  }, {
+    defaultValue: '',
+    displayName: 'Paragraph user input',
+    inputType: UserInputType.PARAGRAPH,
+    required: false,
+    variableName: 'paragraphUserInput'
+  }]
+}];
+export var mockTransformedRules = [_objectSpread(_objectSpread({}, mockRules[0]), {}, {
+  userInputPrompts: mockRules[0].userInputs
+}), _objectSpread(_objectSpread({}, mockRules[1]), {}, {
+  userInputPrompts: mockRules[1].userInputs
+}), _objectSpread(_objectSpread({}, mockRules[2]), {}, {
+  userInputPrompts: mockRules[2].userInputs
+})];
+export var mockInvocationResponse = {
+  'TEST-1': 'SUCCESS'
+};
+export var mockGetUrl = 'https://test-api/get/rules';
+export var mockInvokeUrl = 'https://test-api/invoke';

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

@@ -0,0 +1,118 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+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 React, { Component, Fragment } from 'react';
+import { render } from '@testing-library/react';
+import { DiProvider } from 'react-magnetic-di';
+import { IntlProvider } from 'react-intl-next';
+
+/**
+ * Creates a stubbed invocation API call for triggering rules. Will return
+ * the supplied invocation result for all objects the rule was called
+ * for.
+ */
+export var createStubInvokeManuallyTriggeredRule = function createStubInvokeManuallyTriggeredRule(stubbedInvocationResultForAllObjects, responseDelay) {
+  return /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_env, _site, _ruleId, objects, _inputs) {
+      var response;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            response = objects.reduce(function (acc, current) {
+              return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, current, stubbedInvocationResultForAllObjects));
+            }, {});
+            return _context.abrupt("return", responseDelay ? new Promise(function (resolve) {
+              return setTimeout(resolve, responseDelay);
+            }) : Promise.resolve(response));
+          case 2:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return function (_x, _x2, _x3, _x4, _x5) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+};
+
+/**
+ * Default stubbed invokeManuallyTriggeredRule call. Returns 'SUCCESS' for
+ * all objects the rule was called for.
+ */
+export var successStubInvokeManuallyTriggeredRule = createStubInvokeManuallyTriggeredRule('SUCCESS', 2000);
+var Provider = function Provider(_ref2) {
+  var children = _ref2.children,
+    use = _ref2.use,
+    target = _ref2.target;
+  return /*#__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 var renderWithDi = function renderWithDi(node) {
+  var dependencies = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var options = arguments.length > 2 ? arguments[2] : undefined;
+  return render(node, _objectSpread(_objectSpread({}, options), {}, {
+    wrapper: function wrapper(_ref3) {
+      var _options$wrapper;
+      var children = _ref3.children;
+      var 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: _toConsumableArray(dependencies),
+        target: options === null || options === void 0 ? void 0 : options.target
+      }, /*#__PURE__*/React.createElement(CustomWrapper, null, children));
+    }
+  }));
+};
+export var createGenericComponent = function createGenericComponent(displayName) {
+  var _class;
+  var renderChildren = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  var childrenParams = arguments.length > 2 ? arguments[2] : undefined;
+  return _class = /*#__PURE__*/function (_Component) {
+    _inherits(_class, _Component);
+    var _super = _createSuper(_class);
+    function _class() {
+      _classCallCheck(this, _class);
+      return _super.apply(this, arguments);
+    }
+    _createClass(_class, [{
+      key: "render",
+      value: function 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;
+      }
+    }]);
+    return _class;
+  }(Component), _defineProperty(_class, "displayName", displayName), _class;
+};

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

@@ -0,0 +1,12 @@
+export var UserInputType = /*#__PURE__*/function (UserInputType) {
+  UserInputType["NUMBER"] = "NUMBER";
+  UserInputType["TEXT"] = "TEXT";
+  UserInputType["BOOLEAN"] = "BOOLEAN";
+  UserInputType["DROPDOWN"] = "DROPDOWN";
+  UserInputType["PARAGRAPH"] = "PARAGRAPH";
+  return UserInputType;
+}({});
+export var CORE_PROJECT = 'business';
+export var SOFTWARE_PROJECT = 'software';
+export var SERVICE_DESK_PROJECT = 'service_desk';
+export var PRODUCT_DISCOVERY_PROJECT = 'product_discovery';