@uipath/apollo-react 3.44.1 → 3.44.2-pr255.af80ea0

package/dist/canvas/schema/task-definition/index.cjs

@@ -0,0 +1,60 @@
+"use strict";
+var __webpack_modules__ = {
+    "./task-manifest": function(module) {
+        module.exports = require("./task-manifest.cjs");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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 ('undefined' != 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__);
+    var _task_manifest__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./task-manifest");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _task_manifest__WEBPACK_IMPORTED_MODULE_0__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _task_manifest__WEBPACK_IMPORTED_MODULE_0__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+})();
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/schema/task-definition/index.d.ts

@@ -0,0 +1,2 @@
+export * from './task-manifest';
+//# sourceMappingURL=index.d.ts.map

package/dist/canvas/schema/task-definition/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/canvas/schema/task-definition/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC"}

package/dist/canvas/schema/task-definition/index.js

@@ -0,0 +1 @@
+export * from "./task-manifest.js";

package/dist/canvas/schema/task-definition/task-manifest.cjs

@@ -0,0 +1,78 @@
+"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 ('undefined' != 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__, {
+    taskDisplayManifestSchema: ()=>taskDisplayManifestSchema,
+    taskManifestCollectionSchema: ()=>taskManifestCollectionSchema,
+    taskManifestSchema: ()=>taskManifestSchema,
+    isTaskAllowedInStage: ()=>isTaskAllowedInStage,
+    validateTaskManifestCollection: ()=>validateTaskManifestCollection,
+    validateTaskManifest: ()=>validateTaskManifest
+});
+const external_zod_namespaceObject = require("zod");
+const taskDisplayManifestSchema = external_zod_namespaceObject.z.object({
+    label: external_zod_namespaceObject.z.string().min(1),
+    description: external_zod_namespaceObject.z.string().optional(),
+    icon: external_zod_namespaceObject.z.string().min(1)
+});
+const taskManifestSchema = external_zod_namespaceObject.z.object({
+    taskType: external_zod_namespaceObject.z.string().min(1),
+    version: external_zod_namespaceObject.z.string().min(1),
+    category: external_zod_namespaceObject.z.string().optional(),
+    tags: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()),
+    sortOrder: external_zod_namespaceObject.z.number().int().nonnegative(),
+    display: taskDisplayManifestSchema,
+    allowedStageTypes: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional(),
+    defaultProperties: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.unknown()).optional(),
+    deprecated: external_zod_namespaceObject.z.boolean().optional()
+});
+const taskManifestCollectionSchema = external_zod_namespaceObject.z.array(taskManifestSchema);
+function validateTaskManifest(manifest) {
+    return taskManifestSchema.parse(manifest);
+}
+function validateTaskManifestCollection(manifests) {
+    return taskManifestCollectionSchema.parse(manifests);
+}
+function isTaskAllowedInStage(manifest, stageNodeType) {
+    if (!manifest.allowedStageTypes || 0 === manifest.allowedStageTypes.length) return true;
+    return manifest.allowedStageTypes.includes(stageNodeType);
+}
+exports.isTaskAllowedInStage = __webpack_exports__.isTaskAllowedInStage;
+exports.taskDisplayManifestSchema = __webpack_exports__.taskDisplayManifestSchema;
+exports.taskManifestCollectionSchema = __webpack_exports__.taskManifestCollectionSchema;
+exports.taskManifestSchema = __webpack_exports__.taskManifestSchema;
+exports.validateTaskManifest = __webpack_exports__.validateTaskManifest;
+exports.validateTaskManifestCollection = __webpack_exports__.validateTaskManifestCollection;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "isTaskAllowedInStage",
+    "taskDisplayManifestSchema",
+    "taskManifestCollectionSchema",
+    "taskManifestSchema",
+    "validateTaskManifest",
+    "validateTaskManifestCollection"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/schema/task-definition/task-manifest.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export declare const taskDisplayManifestSchema: z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    icon: z.ZodString;
+}, z.core.$strip>;
+export declare const taskManifestSchema: z.ZodObject<{
+    taskType: z.ZodString;
+    version: z.ZodString;
+    category: z.ZodOptional<z.ZodString>;
+    tags: z.ZodArray<z.ZodString>;
+    sortOrder: z.ZodNumber;
+    display: z.ZodObject<{
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        icon: z.ZodString;
+    }, z.core.$strip>;
+    allowedStageTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    defaultProperties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const taskManifestCollectionSchema: z.ZodArray<z.ZodObject<{
+    taskType: z.ZodString;
+    version: z.ZodString;
+    category: z.ZodOptional<z.ZodString>;
+    tags: z.ZodArray<z.ZodString>;
+    sortOrder: z.ZodNumber;
+    display: z.ZodObject<{
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        icon: z.ZodString;
+    }, z.core.$strip>;
+    allowedStageTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    defaultProperties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>>;
+export type TaskDisplayManifest = z.infer<typeof taskDisplayManifestSchema>;
+export type TaskManifest = z.infer<typeof taskManifestSchema>;
+export type TaskManifestCollection = z.infer<typeof taskManifestCollectionSchema>;
+export declare function validateTaskManifest(manifest: unknown): TaskManifest;
+export declare function validateTaskManifestCollection(manifests: unknown): TaskManifestCollection;
+export declare function isTaskAllowedInStage(manifest: TaskManifest, stageNodeType: string): boolean;
+//# sourceMappingURL=task-manifest.d.ts.map

package/dist/canvas/schema/task-definition/task-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-manifest.d.ts","sourceRoot":"","sources":["../../../../src/canvas/schema/task-definition/task-manifest.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAmBxB,eAAO,MAAM,yBAAyB;;;;iBASpC,CAAC;AAKH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;iBAqC7B,CAAC;AAKH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;kBAA8B,CAAC;AAGxE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAKlF,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,OAAO,GAAG,YAAY,CAEpE;AAKD,wBAAgB,8BAA8B,CAAC,SAAS,EAAE,OAAO,GAAG,sBAAsB,CAEzF;AAKD,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,YAAY,EACtB,aAAa,EAAE,MAAM,GACpB,OAAO,CAMT"}

package/dist/canvas/schema/task-definition/task-manifest.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+const taskDisplayManifestSchema = z.object({
+    label: z.string().min(1),
+    description: z.string().optional(),
+    icon: z.string().min(1)
+});
+const taskManifestSchema = z.object({
+    taskType: z.string().min(1),
+    version: z.string().min(1),
+    category: z.string().optional(),
+    tags: z.array(z.string()),
+    sortOrder: z.number().int().nonnegative(),
+    display: taskDisplayManifestSchema,
+    allowedStageTypes: z.array(z.string()).optional(),
+    defaultProperties: z.record(z.string(), z.unknown()).optional(),
+    deprecated: z.boolean().optional()
+});
+const taskManifestCollectionSchema = z.array(taskManifestSchema);
+function validateTaskManifest(manifest) {
+    return taskManifestSchema.parse(manifest);
+}
+function validateTaskManifestCollection(manifests) {
+    return taskManifestCollectionSchema.parse(manifests);
+}
+function isTaskAllowedInStage(manifest, stageNodeType) {
+    if (!manifest.allowedStageTypes || 0 === manifest.allowedStageTypes.length) return true;
+    return manifest.allowedStageTypes.includes(stageNodeType);
+}
+export { isTaskAllowedInStage, taskDisplayManifestSchema, taskManifestCollectionSchema, taskManifestSchema, validateTaskManifest, validateTaskManifestCollection };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/apollo-react",
-  "version": "3.44.1",
+  "version": "3.44.2-pr255.af80ea0",
   "description": "Apollo Design System - React component library with Material UI theming",
   "repository": {
     "type": "git",

package/dist/canvas/components/StageNode/DraggableTask.cjs

@@ -1,271 +0,0 @@
-"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 ('undefined' != 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__, {
-    TaskContent: ()=>TaskContent,
-    DraggableTask: ()=>DraggableTask
-});
-const jsx_runtime_namespaceObject = require("react/jsx-runtime");
-const sortable_namespaceObject = require("@dnd-kit/sortable");
-const utilities_namespaceObject = require("@dnd-kit/utilities");
-const apollo_core_namespaceObject = require("@uipath/apollo-core");
-const index_cjs_namespaceObject = require("../../layouts/index.cjs");
-const external_material_index_cjs_namespaceObject = require("../../../material/index.cjs");
-const external_react_namespaceObject = require("react");
-const external_ExecutionStatusIcon_index_cjs_namespaceObject = require("../ExecutionStatusIcon/index.cjs");
-const external_StageNode_styles_cjs_namespaceObject = require("./StageNode.styles.cjs");
-const external_TaskMenu_cjs_namespaceObject = require("./TaskMenu.cjs");
-const ProcessNodeIcon = ()=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("svg", {
-        viewBox: "0 0 24 24",
-        fill: "none",
-        stroke: "currentColor",
-        strokeWidth: "1.5",
-        children: [
-            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("rect", {
-                x: "3",
-                y: "3",
-                width: "7",
-                height: "7",
-                rx: "1"
-            }),
-            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("rect", {
-                x: "14",
-                y: "3",
-                width: "7",
-                height: "7",
-                rx: "1"
-            }),
-            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("rect", {
-                x: "3",
-                y: "14",
-                width: "7",
-                height: "7",
-                rx: "1"
-            }),
-            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("rect", {
-                x: "14",
-                y: "14",
-                width: "7",
-                height: "7",
-                rx: "1"
-            })
-        ]
-    });
-const generateBadgeText = (taskExecution)=>{
-    if (!taskExecution.badge) return;
-    if (taskExecution.retryCount && taskExecution.retryCount > 1) return `${taskExecution.badge} x${taskExecution.retryCount}`;
-    return taskExecution.badge;
-};
-const TaskContent = /*#__PURE__*/ (0, external_react_namespaceObject.memo)(({ task, taskExecution, isDragging })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(jsx_runtime_namespaceObject.Fragment, {
-        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(index_cjs_namespaceObject.Column, {
-            flex: 1,
-            style: {
-                overflow: 'hidden',
-                textOverflow: 'ellipsis',
-                whiteSpace: 'nowrap'
-            },
-            gap: apollo_core_namespaceObject.Padding.PadXs,
-            children: [
-                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(index_cjs_namespaceObject.Row, {
-                    align: "center",
-                    justify: "space-between",
-                    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.StageTaskIcon, {
-                                    children: task.icon ?? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(ProcessNodeIcon, {})
-                                }),
-                                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_material_index_cjs_namespaceObject.ApTooltip, {
-                                    content: task.label,
-                                    placement: "top",
-                                    smartTooltip: true,
-                                    ...isDragging && {
-                                        isOpen: false
-                                    },
-                                    children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_material_index_cjs_namespaceObject.ApTypography, {
-                                        variant: apollo_core_namespaceObject.FontVariantToken.fontSizeM,
-                                        color: "var(--uix-canvas-foreground)",
-                                        style: {
-                                            overflow: 'hidden',
-                                            textOverflow: 'ellipsis',
-                                            whiteSpace: 'nowrap'
-                                        },
-                                        children: task.label
-                                    })
-                                })
-                            ]
-                        }),
-                        taskExecution?.status && (taskExecution.message ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_material_index_cjs_namespaceObject.ApTooltip, {
-                            content: taskExecution.message,
-                            placement: "top",
-                            children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_ExecutionStatusIcon_index_cjs_namespaceObject.ExecutionStatusIcon, {
-                                status: taskExecution.status
-                            })
-                        }) : /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_ExecutionStatusIcon_index_cjs_namespaceObject.ExecutionStatusIcon, {
-                            status: taskExecution.status
-                        }))
-                    ]
-                }),
-                taskExecution && (taskExecution.duration || taskExecution.retryDuration || taskExecution.badge) && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(index_cjs_namespaceObject.Row, {
-                    align: "center",
-                    justify: "space-between",
-                    children: [
-                        /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(index_cjs_namespaceObject.Row, {
-                            gap: '2px',
-                            children: [
-                                taskExecution?.duration && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_material_index_cjs_namespaceObject.ApTypography, {
-                                    variant: apollo_core_namespaceObject.FontVariantToken.fontSizeS,
-                                    color: "var(--uix-canvas-foreground-de-emp)",
-                                    children: taskExecution.duration
-                                }),
-                                taskExecution?.retryDuration && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_StageNode_styles_cjs_namespaceObject.StageTaskRetryDuration, {
-                                    status: taskExecution.badgeStatus ?? 'warning',
-                                    children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_material_index_cjs_namespaceObject.ApTypography, {
-                                        variant: apollo_core_namespaceObject.FontVariantToken.fontSizeS,
-                                        color: "inherit",
-                                        children: `(+${taskExecution.retryDuration})`
-                                    })
-                                })
-                            ]
-                        }),
-                        taskExecution?.badge && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_material_index_cjs_namespaceObject.ApBadge, {
-                            size: external_material_index_cjs_namespaceObject.BadgeSize.SMALL,
-                            status: taskExecution.badgeStatus,
-                            label: generateBadgeText(taskExecution) ?? ''
-                        })
-                    ]
-                })
-            ]
-        })
-    }));
-const DraggableTaskComponent = ({ task, taskExecution, isSelected, isParallel, contextMenuItems, onTaskClick, onMenuOpen, isDragDisabled, projectedDepth, zoom = 1 })=>{
-    const [isMenuOpen, setIsMenuOpen] = (0, external_react_namespaceObject.useState)(false);
-    const taskRef = (0, external_react_namespaceObject.useRef)(null);
-    const menuRef = (0, external_react_namespaceObject.useRef)(null);
-    const handleClick = (0, external_react_namespaceObject.useCallback)((e)=>{
-        if (isMenuOpen) return;
-        onTaskClick(e, task.id);
-    }, [
-        isMenuOpen,
-        onTaskClick,
-        task.id
-    ]);
-    const handleMenuOpenChange = (0, external_react_namespaceObject.useCallback)((isOpen)=>{
-        setIsMenuOpen(isOpen);
-    }, []);
-    const handleContextMenu = (0, external_react_namespaceObject.useCallback)((e)=>{
-        menuRef.current?.handleContextMenu(e);
-    }, []);
-    const { attributes, listeners, setNodeRef, transition, transform, isDragging } = (0, sortable_namespaceObject.useSortable)({
-        id: task.id,
-        disabled: isDragDisabled
-    });
-    const style = (0, external_react_namespaceObject.useMemo)(()=>{
-        const scaledTransform = transform ? {
-            ...transform,
-            x: transform.x / zoom,
-            y: transform.y / zoom
-        } : null;
-        let marginLeft;
-        if (isDragging && void 0 !== projectedDepth) if (1 !== projectedDepth || isParallel) {
-            if (0 === projectedDepth && isParallel) marginLeft = `-${external_StageNode_styles_cjs_namespaceObject.INDENTATION_WIDTH}px`;
-        } else marginLeft = `${external_StageNode_styles_cjs_namespaceObject.INDENTATION_WIDTH}px`;
-        return {
-            transition,
-            transform: utilities_namespaceObject.CSS.Transform.toString(scaledTransform),
-            marginLeft
-        };
-    }, [
-        transform,
-        zoom,
-        transition,
-        isDragging,
-        projectedDepth,
-        isParallel
-    ]);
-    if (isDragging) {
-        const isTargetParallel = 1 === projectedDepth;
-        return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_StageNode_styles_cjs_namespaceObject.StageTaskDragPlaceholderWrapper, {
-            ref: setNodeRef,
-            style: style,
-            children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_StageNode_styles_cjs_namespaceObject.StageTaskDragPlaceholder, {
-                isTargetParallel: isTargetParallel
-            })
-        });
-    }
-    const taskElement = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(external_StageNode_styles_cjs_namespaceObject.StageTask, {
-        ref: taskRef,
-        "data-testid": `stage-task-${task.id}`,
-        selected: isSelected,
-        status: taskExecution?.status,
-        isParallel: isParallel,
-        isDragEnabled: !isDragDisabled,
-        isMenuOpen: isMenuOpen,
-        onClick: handleClick,
-        ...contextMenuItems.length > 0 && {
-            onContextMenu: handleContextMenu
-        },
-        children: [
-            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(TaskContent, {
-                task: task,
-                taskExecution: taskExecution
-            }),
-            contextMenuItems.length > 0 && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_TaskMenu_cjs_namespaceObject.TaskMenu, {
-                ref: menuRef,
-                taskId: task.id,
-                contextMenuItems: contextMenuItems,
-                onMenuOpenChange: handleMenuOpenChange,
-                onMenuOpen: onMenuOpen,
-                taskRef: taskRef
-            })
-        ]
-    });
-    if (isDragDisabled) return taskElement;
-    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_StageNode_styles_cjs_namespaceObject.StageTaskWrapper, {
-        ref: setNodeRef,
-        style: style,
-        isParallel: isParallel,
-        ...attributes,
-        ...listeners,
-        children: taskElement
-    });
-};
-const DraggableTask = /*#__PURE__*/ (0, external_react_namespaceObject.memo)(DraggableTaskComponent);
-exports.DraggableTask = __webpack_exports__.DraggableTask;
-exports.TaskContent = __webpack_exports__.TaskContent;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "DraggableTask",
-    "TaskContent"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/canvas/components/StageNode/DraggableTask.d.ts

@@ -1,4 +0,0 @@
-import type { DraggableTaskProps, TaskContentProps } from './DraggableTask.types';
-export declare const TaskContent: import("react").MemoExoticComponent<({ task, taskExecution, isDragging }: TaskContentProps) => import("react/jsx-runtime").JSX.Element>;
-export declare const DraggableTask: import("react").MemoExoticComponent<({ task, taskExecution, isSelected, isParallel, contextMenuItems, onTaskClick, onMenuOpen, isDragDisabled, projectedDepth, zoom, }: DraggableTaskProps) => import("react/jsx-runtime").JSX.Element>;
-//# sourceMappingURL=DraggableTask.d.ts.map

package/dist/canvas/components/StageNode/DraggableTask.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DraggableTask.d.ts","sourceRoot":"","sources":["../../../../src/canvas/components/StageNode/DraggableTask.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAgClF,eAAO,MAAM,WAAW,4EAA8C,gBAAgB,6CAsEpF,CAAC;AAqHH,eAAO,MAAM,aAAa,0KAxGvB,kBAAkB,6CAwGoC,CAAC"}