@uipath/apollo-react 6.13.0 → 6.15.0

package/dist/canvas/components/StageNode/rules/CompletionRulesContainer.js

@@ -0,0 +1,35 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { StageItemsSection } from "../StageNode.styles.js";
+import { CollapsibleStageHeader } from "../shared/CollapsibleStageHeader.js";
+import { StageItemsHeaderTitle } from "../shared/StageItemsHeaderTitle.js";
+import { StageRulesContainer } from "./StageRulesContainer.js";
+const CompletionRulesContainer = ({ props, isReadOnly })=>{
+    const { id, stageDetails } = props;
+    const { completionRules, sectionStates } = stageDetails;
+    if (!completionRules || 0 === completionRules.length) return null;
+    let rulesContainer = /*#__PURE__*/ jsx(StageRulesContainer, {
+        rules: completionRules,
+        ruleType: "completion",
+        isReadOnly: isReadOnly
+    });
+    rulesContainer = sectionStates?.completionRules ? /*#__PURE__*/ jsx(CollapsibleStageHeader, {
+        isOpen: !sectionStates.completionRules.isCollapsed,
+        label: "Completion rules",
+        testId: `completion-rules-header-${id}`,
+        onToggle: sectionStates.completionRules.onCollapsedToggle,
+        children: rulesContainer
+    }) : /*#__PURE__*/ jsxs(StageItemsSection, {
+        children: [
+            /*#__PURE__*/ jsx(StageItemsHeaderTitle, {
+                title: "Completion rules",
+                testId: `completion-rules-header-${id}`
+            }),
+            rulesContainer
+        ]
+    });
+    return /*#__PURE__*/ jsx("div", {
+        "data-testid": `completion-rules-container-${id}`,
+        children: rulesContainer
+    });
+};
+export { CompletionRulesContainer };

package/dist/canvas/components/StageNode/rules/EntryRulesContainer.cjs

@@ -0,0 +1,69 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    EntryRulesContainer: ()=>EntryRulesContainer
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_StageNode_styles_cjs_namespaceObject = require("../StageNode.styles.cjs");
+const CollapsibleStageHeader_cjs_namespaceObject = require("../shared/CollapsibleStageHeader.cjs");
+const StageItemsHeaderTitle_cjs_namespaceObject = require("../shared/StageItemsHeaderTitle.cjs");
+const external_StageRulesContainer_cjs_namespaceObject = require("./StageRulesContainer.cjs");
+const EntryRulesContainer = ({ props, isReadOnly })=>{
+    const { id, stageDetails } = props;
+    const { entryRules, sectionStates } = stageDetails;
+    if (!entryRules || 0 === entryRules.length) return null;
+    let rulesContainer = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_StageRulesContainer_cjs_namespaceObject.StageRulesContainer, {
+        rules: entryRules,
+        ruleType: "entry",
+        isReadOnly: isReadOnly
+    });
+    rulesContainer = sectionStates?.entryRules ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(CollapsibleStageHeader_cjs_namespaceObject.CollapsibleStageHeader, {
+        isOpen: !sectionStates.entryRules.isCollapsed,
+        label: "Entry rules",
+        testId: `entry-rules-header-${id}`,
+        onToggle: sectionStates.entryRules.onCollapsedToggle,
+        children: rulesContainer
+    }) : /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(external_StageNode_styles_cjs_namespaceObject.StageItemsSection, {
+        children: [
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(StageItemsHeaderTitle_cjs_namespaceObject.StageItemsHeaderTitle, {
+                title: "Entry rules",
+                testId: `entry-rules-header-${id}`
+            }),
+            rulesContainer
+        ]
+    });
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+        "data-testid": `entry-rules-container-${id}`,
+        children: rulesContainer
+    });
+};
+exports.EntryRulesContainer = __webpack_exports__.EntryRulesContainer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "EntryRulesContainer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/components/StageNode/rules/EntryRulesContainer.d.ts

@@ -0,0 +1,8 @@
+import type { StageNodeProps } from '../StageNode.types';
+interface EntryRulesContainerProps {
+    props: StageNodeProps;
+    isReadOnly: boolean;
+}
+export declare const EntryRulesContainer: ({ props, isReadOnly }: EntryRulesContainerProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};
+//# sourceMappingURL=EntryRulesContainer.d.ts.map

package/dist/canvas/components/StageNode/rules/EntryRulesContainer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntryRulesContainer.d.ts","sourceRoot":"","sources":["../../../../../src/canvas/components/StageNode/rules/EntryRulesContainer.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAKzD,UAAU,wBAAwB;IAChC,KAAK,EAAE,cAAc,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,eAAO,MAAM,mBAAmB,GAAI,uBAAuB,wBAAwB,mDAiClF,CAAC"}

package/dist/canvas/components/StageNode/rules/EntryRulesContainer.js

@@ -0,0 +1,35 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { StageItemsSection } from "../StageNode.styles.js";
+import { CollapsibleStageHeader } from "../shared/CollapsibleStageHeader.js";
+import { StageItemsHeaderTitle } from "../shared/StageItemsHeaderTitle.js";
+import { StageRulesContainer } from "./StageRulesContainer.js";
+const EntryRulesContainer = ({ props, isReadOnly })=>{
+    const { id, stageDetails } = props;
+    const { entryRules, sectionStates } = stageDetails;
+    if (!entryRules || 0 === entryRules.length) return null;
+    let rulesContainer = /*#__PURE__*/ jsx(StageRulesContainer, {
+        rules: entryRules,
+        ruleType: "entry",
+        isReadOnly: isReadOnly
+    });
+    rulesContainer = sectionStates?.entryRules ? /*#__PURE__*/ jsx(CollapsibleStageHeader, {
+        isOpen: !sectionStates.entryRules.isCollapsed,
+        label: "Entry rules",
+        testId: `entry-rules-header-${id}`,
+        onToggle: sectionStates.entryRules.onCollapsedToggle,
+        children: rulesContainer
+    }) : /*#__PURE__*/ jsxs(StageItemsSection, {
+        children: [
+            /*#__PURE__*/ jsx(StageItemsHeaderTitle, {
+                title: "Entry rules",
+                testId: `entry-rules-header-${id}`
+            }),
+            rulesContainer
+        ]
+    });
+    return /*#__PURE__*/ jsx("div", {
+        "data-testid": `entry-rules-container-${id}`,
+        children: rulesContainer
+    });
+};
+export { EntryRulesContainer };

package/dist/canvas/components/StageNode/rules/ExitRulesContainer.cjs

@@ -0,0 +1,69 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ExitRulesContainer: ()=>ExitRulesContainer
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_StageNode_styles_cjs_namespaceObject = require("../StageNode.styles.cjs");
+const CollapsibleStageHeader_cjs_namespaceObject = require("../shared/CollapsibleStageHeader.cjs");
+const StageItemsHeaderTitle_cjs_namespaceObject = require("../shared/StageItemsHeaderTitle.cjs");
+const external_StageRulesContainer_cjs_namespaceObject = require("./StageRulesContainer.cjs");
+const ExitRulesContainer = ({ props, isReadOnly })=>{
+    const { id, stageDetails } = props;
+    const { exitRules, sectionStates } = stageDetails;
+    if (!exitRules || 0 === exitRules.length) return null;
+    let rulesContainer = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_StageRulesContainer_cjs_namespaceObject.StageRulesContainer, {
+        rules: exitRules,
+        ruleType: "exit",
+        isReadOnly: isReadOnly
+    });
+    rulesContainer = sectionStates?.exitRules ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(CollapsibleStageHeader_cjs_namespaceObject.CollapsibleStageHeader, {
+        isOpen: !sectionStates.exitRules.isCollapsed,
+        label: "Exit rules",
+        testId: `exit-rules-header-${id}`,
+        onToggle: sectionStates.exitRules.onCollapsedToggle,
+        children: rulesContainer
+    }) : /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(external_StageNode_styles_cjs_namespaceObject.StageItemsSection, {
+        children: [
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(StageItemsHeaderTitle_cjs_namespaceObject.StageItemsHeaderTitle, {
+                title: "Exit rules",
+                testId: `exit-rules-header-${id}`
+            }),
+            rulesContainer
+        ]
+    });
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+        "data-testid": `exit-rules-container-${id}`,
+        children: rulesContainer
+    });
+};
+exports.ExitRulesContainer = __webpack_exports__.ExitRulesContainer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ExitRulesContainer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/components/StageNode/rules/ExitRulesContainer.d.ts

@@ -0,0 +1,8 @@
+import type { StageNodeProps } from '../StageNode.types';
+interface ExitRulesContainerProps {
+    props: StageNodeProps;
+    isReadOnly: boolean;
+}
+export declare const ExitRulesContainer: ({ props, isReadOnly }: ExitRulesContainerProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};
+//# sourceMappingURL=ExitRulesContainer.d.ts.map

package/dist/canvas/components/StageNode/rules/ExitRulesContainer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExitRulesContainer.d.ts","sourceRoot":"","sources":["../../../../../src/canvas/components/StageNode/rules/ExitRulesContainer.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAKzD,UAAU,uBAAuB;IAC/B,KAAK,EAAE,cAAc,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,eAAO,MAAM,kBAAkB,GAAI,uBAAuB,uBAAuB,mDAiChF,CAAC"}

package/dist/canvas/components/StageNode/rules/ExitRulesContainer.js

@@ -0,0 +1,35 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { StageItemsSection } from "../StageNode.styles.js";
+import { CollapsibleStageHeader } from "../shared/CollapsibleStageHeader.js";
+import { StageItemsHeaderTitle } from "../shared/StageItemsHeaderTitle.js";
+import { StageRulesContainer } from "./StageRulesContainer.js";
+const ExitRulesContainer = ({ props, isReadOnly })=>{
+    const { id, stageDetails } = props;
+    const { exitRules, sectionStates } = stageDetails;
+    if (!exitRules || 0 === exitRules.length) return null;
+    let rulesContainer = /*#__PURE__*/ jsx(StageRulesContainer, {
+        rules: exitRules,
+        ruleType: "exit",
+        isReadOnly: isReadOnly
+    });
+    rulesContainer = sectionStates?.exitRules ? /*#__PURE__*/ jsx(CollapsibleStageHeader, {
+        isOpen: !sectionStates.exitRules.isCollapsed,
+        label: "Exit rules",
+        testId: `exit-rules-header-${id}`,
+        onToggle: sectionStates.exitRules.onCollapsedToggle,
+        children: rulesContainer
+    }) : /*#__PURE__*/ jsxs(StageItemsSection, {
+        children: [
+            /*#__PURE__*/ jsx(StageItemsHeaderTitle, {
+                title: "Exit rules",
+                testId: `exit-rules-header-${id}`
+            }),
+            rulesContainer
+        ]
+    });
+    return /*#__PURE__*/ jsx("div", {
+        "data-testid": `exit-rules-container-${id}`,
+        children: rulesContainer
+    });
+};
+export { ExitRulesContainer };

package/dist/canvas/components/StageNode/rules/StageRuleContent.cjs

@@ -0,0 +1,100 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    StageRuleContent: ()=>StageRuleContent
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const apollo_core_namespaceObject = require("@uipath/apollo-core");
+const index_cjs_namespaceObject = require("../../../layouts/index.cjs");
+const external_react_namespaceObject = require("react");
+const external_CanvasTooltip_cjs_namespaceObject = require("../../CanvasTooltip.cjs");
+const external_StageNode_styles_cjs_namespaceObject = require("../StageNode.styles.cjs");
+const StageCompletionConditionIcon_cjs_namespaceObject = require("../shared/StageCompletionConditionIcon.cjs");
+const StageEntryConditionIcon_cjs_namespaceObject = require("../shared/StageEntryConditionIcon.cjs");
+const StageExitConditionIcon_cjs_namespaceObject = require("../shared/StageExitConditionIcon.cjs");
+const StageRuleContent = /*#__PURE__*/ (0, external_react_namespaceObject.memo)(({ rule, ruleType })=>{
+    const icon = (0, external_react_namespaceObject.useMemo)(()=>{
+        if ('entry' === ruleType) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(StageEntryConditionIcon_cjs_namespaceObject.StageEntryConditionIcon, {});
+        if ('exit' === ruleType) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(StageExitConditionIcon_cjs_namespaceObject.StageExitConditionIcon, {});
+        if ('completion' === ruleType) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(StageCompletionConditionIcon_cjs_namespaceObject.StageCompletionConditionIcon, {});
+        return null;
+    }, [
+        ruleType
+    ]);
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(index_cjs_namespaceObject.Row, {
+        flex: 1,
+        align: "center",
+        justify: "space-between",
+        gap: apollo_core_namespaceObject.Spacing.SpacingXs,
+        style: {
+            overflow: 'hidden'
+        },
+        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(index_cjs_namespaceObject.Row, {
+            gap: apollo_core_namespaceObject.Spacing.SpacingXs,
+            align: "center",
+            style: {
+                overflow: 'hidden',
+                textOverflow: 'ellipsis',
+                whiteSpace: 'nowrap'
+            },
+            children: [
+                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_StageNode_styles_cjs_namespaceObject.StageItemIcon, {
+                    "data-testid": `stage-rule-icon-${rule.id}`,
+                    children: icon
+                }),
+                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_CanvasTooltip_cjs_namespaceObject.CanvasTooltip, {
+                    content: rule.label,
+                    placement: "top",
+                    smartTooltip: true,
+                    children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(index_cjs_namespaceObject.Row, {
+                        gap: '2px',
+                        align: "center",
+                        style: {
+                            overflow: 'hidden',
+                            textOverflow: 'ellipsis',
+                            whiteSpace: 'nowrap'
+                        },
+                        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("span", {
+                            "data-testid": `stage-rule-label-${rule.id}`,
+                            className: "text-sm truncate",
+                            style: {
+                                minWidth: 0
+                            },
+                            children: rule.label
+                        })
+                    })
+                })
+            ]
+        })
+    });
+});
+exports.StageRuleContent = __webpack_exports__.StageRuleContent;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "StageRuleContent"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/components/StageNode/rules/StageRuleContent.d.ts

@@ -0,0 +1,7 @@
+import type { StageRule, StageRuleType } from '../StageNode.types';
+export interface StageRuleContentProps {
+    rule: StageRule;
+    ruleType: StageRuleType;
+}
+export declare const StageRuleContent: import("react").MemoExoticComponent<({ rule, ruleType }: StageRuleContentProps) => import("react/jsx-runtime").JSX.Element>;
+//# sourceMappingURL=StageRuleContent.d.ts.map

package/dist/canvas/components/StageNode/rules/StageRuleContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StageRuleContent.d.ts","sourceRoot":"","sources":["../../../../../src/canvas/components/StageNode/rules/StageRuleContent.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAKnE,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,SAAS,CAAC;IAChB,QAAQ,EAAE,aAAa,CAAC;CACzB;AAED,eAAO,MAAM,gBAAgB,2DAA6B,qBAAqB,6CA4C7E,CAAC"}

package/dist/canvas/components/StageNode/rules/StageRuleContent.js

@@ -0,0 +1,66 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Spacing } from "@uipath/apollo-core";
+import { Row } from "../../../layouts/index.js";
+import { memo, useMemo } from "react";
+import { CanvasTooltip } from "../../CanvasTooltip.js";
+import { StageItemIcon } from "../StageNode.styles.js";
+import { StageCompletionConditionIcon } from "../shared/StageCompletionConditionIcon.js";
+import { StageEntryConditionIcon } from "../shared/StageEntryConditionIcon.js";
+import { StageExitConditionIcon } from "../shared/StageExitConditionIcon.js";
+const StageRuleContent = /*#__PURE__*/ memo(({ rule, ruleType })=>{
+    const icon = useMemo(()=>{
+        if ('entry' === ruleType) return /*#__PURE__*/ jsx(StageEntryConditionIcon, {});
+        if ('exit' === ruleType) return /*#__PURE__*/ jsx(StageExitConditionIcon, {});
+        if ('completion' === ruleType) return /*#__PURE__*/ jsx(StageCompletionConditionIcon, {});
+        return null;
+    }, [
+        ruleType
+    ]);
+    return /*#__PURE__*/ jsx(Row, {
+        flex: 1,
+        align: "center",
+        justify: "space-between",
+        gap: Spacing.SpacingXs,
+        style: {
+            overflow: 'hidden'
+        },
+        children: /*#__PURE__*/ jsxs(Row, {
+            gap: Spacing.SpacingXs,
+            align: "center",
+            style: {
+                overflow: 'hidden',
+                textOverflow: 'ellipsis',
+                whiteSpace: 'nowrap'
+            },
+            children: [
+                /*#__PURE__*/ jsx(StageItemIcon, {
+                    "data-testid": `stage-rule-icon-${rule.id}`,
+                    children: icon
+                }),
+                /*#__PURE__*/ jsx(CanvasTooltip, {
+                    content: rule.label,
+                    placement: "top",
+                    smartTooltip: true,
+                    children: /*#__PURE__*/ jsx(Row, {
+                        gap: '2px',
+                        align: "center",
+                        style: {
+                            overflow: 'hidden',
+                            textOverflow: 'ellipsis',
+                            whiteSpace: 'nowrap'
+                        },
+                        children: /*#__PURE__*/ jsx("span", {
+                            "data-testid": `stage-rule-label-${rule.id}`,
+                            className: "text-sm truncate",
+                            style: {
+                                minWidth: 0
+                            },
+                            children: rule.label
+                        })
+                    })
+                })
+            ]
+        })
+    });
+});
+export { StageRuleContent };

package/dist/canvas/components/StageNode/rules/StageRuleItemPill.cjs

@@ -0,0 +1,64 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    StageRuleItemPill: ()=>StageRuleItemPill
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_react_namespaceObject = require("react");
+const external_StageNode_styles_cjs_namespaceObject = require("../StageNode.styles.cjs");
+const external_StageRuleContent_cjs_namespaceObject = require("./StageRuleContent.cjs");
+const StageRuleItemPill = ({ rule, ruleType, isReadOnly })=>{
+    const ruleRef = (0, external_react_namespaceObject.useRef)(null);
+    const onClickFunction = isReadOnly ? void 0 : rule.onClick;
+    const hasOnClickFunction = null != onClickFunction;
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_StageNode_styles_cjs_namespaceObject.StageItemPill, {
+        ref: ruleRef,
+        "data-testid": `stage-rule-${rule.id}`,
+        onClick: onClickFunction,
+        role: hasOnClickFunction ? 'button' : void 0,
+        tabIndex: hasOnClickFunction ? 0 : void 0,
+        style: hasOnClickFunction ? {
+            cursor: 'pointer'
+        } : void 0,
+        onKeyDown: (e)=>{
+            if (hasOnClickFunction && ('Enter' === e.key || ' ' === e.key)) {
+                e.preventDefault();
+                onClickFunction();
+            }
+        },
+        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_StageRuleContent_cjs_namespaceObject.StageRuleContent, {
+            rule: rule,
+            ruleType: ruleType
+        })
+    });
+};
+exports.StageRuleItemPill = __webpack_exports__.StageRuleItemPill;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "StageRuleItemPill"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/components/StageNode/rules/StageRuleItemPill.d.ts

@@ -0,0 +1,8 @@
+import type { StageRule, StageRuleType } from '../StageNode.types';
+export interface StageRuleItemPillProps {
+    rule: StageRule;
+    ruleType: StageRuleType;
+    isReadOnly: boolean;
+}
+export declare const StageRuleItemPill: ({ rule, ruleType, isReadOnly }: StageRuleItemPillProps) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=StageRuleItemPill.d.ts.map

package/dist/canvas/components/StageNode/rules/StageRuleItemPill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StageRuleItemPill.d.ts","sourceRoot":"","sources":["../../../../../src/canvas/components/StageNode/rules/StageRuleItemPill.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGnE,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,SAAS,CAAC;IAChB,QAAQ,EAAE,aAAa,CAAC;IACxB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,eAAO,MAAM,iBAAiB,GAAI,gCAAgC,sBAAsB,4CAuBvF,CAAC"}

package/dist/canvas/components/StageNode/rules/StageRuleItemPill.js

@@ -0,0 +1,30 @@
+import { jsx } from "react/jsx-runtime";
+import { useRef } from "react";
+import { StageItemPill } from "../StageNode.styles.js";
+import { StageRuleContent } from "./StageRuleContent.js";
+const StageRuleItemPill = ({ rule, ruleType, isReadOnly })=>{
+    const ruleRef = useRef(null);
+    const onClickFunction = isReadOnly ? void 0 : rule.onClick;
+    const hasOnClickFunction = null != onClickFunction;
+    return /*#__PURE__*/ jsx(StageItemPill, {
+        ref: ruleRef,
+        "data-testid": `stage-rule-${rule.id}`,
+        onClick: onClickFunction,
+        role: hasOnClickFunction ? 'button' : void 0,
+        tabIndex: hasOnClickFunction ? 0 : void 0,
+        style: hasOnClickFunction ? {
+            cursor: 'pointer'
+        } : void 0,
+        onKeyDown: (e)=>{
+            if (hasOnClickFunction && ('Enter' === e.key || ' ' === e.key)) {
+                e.preventDefault();
+                onClickFunction();
+            }
+        },
+        children: /*#__PURE__*/ jsx(StageRuleContent, {
+            rule: rule,
+            ruleType: ruleType
+        })
+    });
+};
+export { StageRuleItemPill };

package/dist/canvas/components/StageNode/rules/StageRulesContainer.cjs

@@ -0,0 +1,50 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    StageRulesContainer: ()=>StageRulesContainer
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_react_namespaceObject = require("react");
+const external_StageNode_styles_cjs_namespaceObject = require("../StageNode.styles.cjs");
+const external_StageRuleItemPill_cjs_namespaceObject = require("./StageRuleItemPill.cjs");
+const StageRulesContainerInner = ({ rules, ruleType, isReadOnly })=>{
+    if (0 === rules.length) return null;
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_StageNode_styles_cjs_namespaceObject.StageItemsList, {
+        children: rules.map((rule)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_StageRuleItemPill_cjs_namespaceObject.StageRuleItemPill, {
+                rule: rule,
+                ruleType: ruleType,
+                isReadOnly: isReadOnly
+            }, rule.id))
+    });
+};
+const StageRulesContainer = /*#__PURE__*/ (0, external_react_namespaceObject.memo)(StageRulesContainerInner);
+exports.StageRulesContainer = __webpack_exports__.StageRulesContainer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "StageRulesContainer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/components/StageNode/rules/StageRulesContainer.d.ts

@@ -0,0 +1,9 @@
+import type { StageRule, StageRuleType } from '../StageNode.types';
+interface StageRulesContainerProps {
+    rules: StageRule[];
+    ruleType: StageRuleType;
+    isReadOnly: boolean;
+}
+export declare const StageRulesContainer: import("react").MemoExoticComponent<({ rules, ruleType, isReadOnly }: StageRulesContainerProps) => import("react/jsx-runtime").JSX.Element | null>;
+export {};
+//# sourceMappingURL=StageRulesContainer.d.ts.map

package/dist/canvas/components/StageNode/rules/StageRulesContainer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StageRulesContainer.d.ts","sourceRoot":"","sources":["../../../../../src/canvas/components/StageNode/rules/StageRulesContainer.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGnE,UAAU,wBAAwB;IAChC,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,QAAQ,EAAE,aAAa,CAAC;IACxB,UAAU,EAAE,OAAO,CAAC;CACrB;AAsBD,eAAO,MAAM,mBAAmB,wEApBmC,wBAAwB,oDAoB1B,CAAC"}

package/dist/canvas/components/StageNode/rules/StageRulesContainer.js

@@ -0,0 +1,16 @@
+import { jsx } from "react/jsx-runtime";
+import { memo } from "react";
+import { StageItemsList } from "../StageNode.styles.js";
+import { StageRuleItemPill } from "./StageRuleItemPill.js";
+const StageRulesContainerInner = ({ rules, ruleType, isReadOnly })=>{
+    if (0 === rules.length) return null;
+    return /*#__PURE__*/ jsx(StageItemsList, {
+        children: rules.map((rule)=>/*#__PURE__*/ jsx(StageRuleItemPill, {
+                rule: rule,
+                ruleType: ruleType,
+                isReadOnly: isReadOnly
+            }, rule.id))
+    });
+};
+const StageRulesContainer = /*#__PURE__*/ memo(StageRulesContainerInner);
+export { StageRulesContainer };