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

package/dist/canvas/components/TaskNode/useTaskPositions.cjs

@@ -0,0 +1,153 @@
+"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__, {
+    DEFAULT_TASK_POSITION_CONFIG: ()=>DEFAULT_TASK_POSITION_CONFIG,
+    calculateStageContentHeight: ()=>calculateStageContentHeight,
+    calculateTaskPositions: ()=>calculateTaskPositions,
+    useTaskPositions: ()=>useTaskPositions
+});
+const external_react_namespaceObject = require("react");
+function calculateExecutionExtraHeight(execution) {
+    if (!execution.duration && !execution.retryDuration && !execution.badge) return 2;
+    if (execution.retryDuration || execution.badge) return 26;
+    return 18;
+}
+const DEFAULT_TASK_POSITION_CONFIG = {
+    stageBorderThickness: 2,
+    taskHeight: 36,
+    taskGap: 12,
+    parallelIndent: 30,
+    contentPaddingTop: 16,
+    contentPaddingBottom: 16,
+    contentPaddingX: 14,
+    headerHeight: 56,
+    headerExecutionDescriptionHeight: 16
+};
+function calculateTaskPositions(taskIds, stageWidth, taskData, stageExecution) {
+    const positions = new Map();
+    const taskRecord = {};
+    if (taskData) if (Array.isArray(taskData)) taskData.forEach((node)=>{
+        taskRecord[node.id] = {
+            execution: node.data?.execution
+        };
+    });
+    else Object.assign(taskRecord, taskData);
+    const taskWidth = stageWidth - 2 * DEFAULT_TASK_POSITION_CONFIG.contentPaddingX;
+    const parallelTaskWidth = taskWidth - DEFAULT_TASK_POSITION_CONFIG.parallelIndent;
+    const headerHeight = stageExecution?.duration ? DEFAULT_TASK_POSITION_CONFIG.headerHeight + DEFAULT_TASK_POSITION_CONFIG.headerExecutionDescriptionHeight : DEFAULT_TASK_POSITION_CONFIG.headerHeight;
+    let currentY = headerHeight + DEFAULT_TASK_POSITION_CONFIG.contentPaddingTop + DEFAULT_TASK_POSITION_CONFIG.stageBorderThickness;
+    for (const group of taskIds){
+        const isParallel = group.length > 1;
+        for(let taskIndex = 0; taskIndex < group.length; taskIndex++){
+            const taskId = group[taskIndex];
+            if (!taskId) continue;
+            const execution = taskRecord[taskId]?.execution;
+            const taskHeight = execution ? DEFAULT_TASK_POSITION_CONFIG.taskHeight + calculateExecutionExtraHeight(execution) : DEFAULT_TASK_POSITION_CONFIG.taskHeight;
+            positions.set(taskId, {
+                x: isParallel ? DEFAULT_TASK_POSITION_CONFIG.contentPaddingX + DEFAULT_TASK_POSITION_CONFIG.parallelIndent : DEFAULT_TASK_POSITION_CONFIG.contentPaddingX,
+                y: currentY,
+                width: isParallel ? parallelTaskWidth : taskWidth
+            });
+            currentY += taskHeight;
+            if (taskIndex < group.length - 1) currentY += DEFAULT_TASK_POSITION_CONFIG.taskGap;
+        }
+        currentY += DEFAULT_TASK_POSITION_CONFIG.taskGap;
+    }
+    return positions;
+}
+function calculateStageContentHeight(taskIds, taskData) {
+    const taskRecord = {};
+    if (taskData) if (Array.isArray(taskData)) taskData.forEach((node)=>{
+        taskRecord[node.id] = {
+            execution: node.data?.execution
+        };
+    });
+    else Object.assign(taskRecord, taskData);
+    let height = DEFAULT_TASK_POSITION_CONFIG.contentPaddingTop;
+    for (const group of taskIds)for (const taskId of group){
+        const execution = taskRecord[taskId]?.execution;
+        const taskHeight = execution ? DEFAULT_TASK_POSITION_CONFIG.taskHeight + calculateExecutionExtraHeight(execution) : DEFAULT_TASK_POSITION_CONFIG.taskHeight;
+        height += taskHeight + DEFAULT_TASK_POSITION_CONFIG.taskGap;
+    }
+    if (taskIds.length > 0) {
+        height -= DEFAULT_TASK_POSITION_CONFIG.taskGap;
+        height += DEFAULT_TASK_POSITION_CONFIG.contentPaddingBottom;
+    }
+    return height;
+}
+function useTaskPositions(taskIds, stageWidth, stageExecution) {
+    const positions = (0, external_react_namespaceObject.useMemo)(()=>calculateTaskPositions(taskIds, stageWidth, void 0, stageExecution), [
+        taskIds,
+        stageWidth,
+        stageExecution
+    ]);
+    const contentHeight = (0, external_react_namespaceObject.useMemo)(()=>calculateStageContentHeight(taskIds, void 0), [
+        taskIds
+    ]);
+    const getPosition = (0, external_react_namespaceObject.useCallback)((taskId)=>positions.get(taskId), [
+        positions
+    ]);
+    const isParallel = (0, external_react_namespaceObject.useCallback)((taskId)=>{
+        for (const group of taskIds)if (group.includes(taskId)) return group.length > 1;
+        return false;
+    }, [
+        taskIds
+    ]);
+    const getGroupInfo = (0, external_react_namespaceObject.useCallback)((taskId)=>{
+        for(let groupIndex = 0; groupIndex < taskIds.length; groupIndex++){
+            const group = taskIds[groupIndex];
+            if (!group) continue;
+            const taskIndex = group.indexOf(taskId);
+            if (-1 !== taskIndex) return {
+                groupIndex,
+                taskIndex
+            };
+        }
+        return null;
+    }, [
+        taskIds
+    ]);
+    return {
+        positions,
+        contentHeight,
+        getPosition,
+        isParallel,
+        getGroupInfo
+    };
+}
+exports.DEFAULT_TASK_POSITION_CONFIG = __webpack_exports__.DEFAULT_TASK_POSITION_CONFIG;
+exports.calculateStageContentHeight = __webpack_exports__.calculateStageContentHeight;
+exports.calculateTaskPositions = __webpack_exports__.calculateTaskPositions;
+exports.useTaskPositions = __webpack_exports__.useTaskPositions;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "DEFAULT_TASK_POSITION_CONFIG",
+    "calculateStageContentHeight",
+    "calculateTaskPositions",
+    "useTaskPositions"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/components/TaskNode/useTaskPositions.d.ts

@@ -0,0 +1,29 @@
+import type { TaskPosition, TaskPositionConfig } from './TaskNode.types';
+export declare const DEFAULT_TASK_POSITION_CONFIG: TaskPositionConfig;
+export declare function calculateTaskPositions(taskIds: string[][], stageWidth: number, taskData?: Record<string, {
+    execution?: Record<string, unknown>;
+}> | Array<{
+    id: string;
+    data?: {
+        execution?: Record<string, unknown>;
+    };
+}>, stageExecution?: Record<string, unknown>): Map<string, TaskPosition>;
+export declare function calculateStageContentHeight(taskIds: string[][], taskData?: Record<string, {
+    execution?: Record<string, unknown>;
+}> | Array<{
+    id: string;
+    data?: {
+        execution?: Record<string, unknown>;
+    };
+}>): number;
+export declare function useTaskPositions(taskIds: string[][], stageWidth: number, stageExecution?: Record<string, unknown>): {
+    positions: Map<string, TaskPosition>;
+    contentHeight: number;
+    getPosition: (taskId: string) => TaskPosition | undefined;
+    isParallel: (taskId: string) => boolean;
+    getGroupInfo: (taskId: string) => {
+        groupIndex: number;
+        taskIndex: number;
+    } | null;
+};
+//# sourceMappingURL=useTaskPositions.d.ts.map

package/dist/canvas/components/TaskNode/useTaskPositions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTaskPositions.d.ts","sourceRoot":"","sources":["../../../../src/canvas/components/TaskNode/useTaskPositions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAsBzE,eAAO,MAAM,4BAA4B,EAAE,kBAU1C,CAAC;AAaF,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EAAE,EAAE,EACnB,UAAU,EAAE,MAAM,EAClB,QAAQ,CAAC,EACL,MAAM,CAAC,MAAM,EAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC,GACvD,KAAK,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAA;CAAE,CAAC,EACzE,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACvC,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CA+D3B;AAWD,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,MAAM,EAAE,EAAE,EACnB,QAAQ,CAAC,EACL,MAAM,CAAC,MAAM,EAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC,GACvD,KAAK,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAA;CAAE,CAAC,GACxE,MAAM,CAiCR;AAUD,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EAAE,EAAE,EACnB,UAAU,EAAE,MAAM,EAClB,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;0BAU7B,MAAM,KAAG,YAAY,GAAG,SAAS;yBAKjC,MAAM,KAAG,OAAO;2BAYhB,MAAM,KAAG;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;EAqBrE"}

package/dist/canvas/components/TaskNode/useTaskPositions.js

@@ -0,0 +1,110 @@
+import { useCallback, useMemo } from "react";
+function calculateExecutionExtraHeight(execution) {
+    if (!execution.duration && !execution.retryDuration && !execution.badge) return 2;
+    if (execution.retryDuration || execution.badge) return 26;
+    return 18;
+}
+const DEFAULT_TASK_POSITION_CONFIG = {
+    stageBorderThickness: 2,
+    taskHeight: 36,
+    taskGap: 12,
+    parallelIndent: 30,
+    contentPaddingTop: 16,
+    contentPaddingBottom: 16,
+    contentPaddingX: 14,
+    headerHeight: 56,
+    headerExecutionDescriptionHeight: 16
+};
+function calculateTaskPositions(taskIds, stageWidth, taskData, stageExecution) {
+    const positions = new Map();
+    const taskRecord = {};
+    if (taskData) if (Array.isArray(taskData)) taskData.forEach((node)=>{
+        taskRecord[node.id] = {
+            execution: node.data?.execution
+        };
+    });
+    else Object.assign(taskRecord, taskData);
+    const taskWidth = stageWidth - 2 * DEFAULT_TASK_POSITION_CONFIG.contentPaddingX;
+    const parallelTaskWidth = taskWidth - DEFAULT_TASK_POSITION_CONFIG.parallelIndent;
+    const headerHeight = stageExecution?.duration ? DEFAULT_TASK_POSITION_CONFIG.headerHeight + DEFAULT_TASK_POSITION_CONFIG.headerExecutionDescriptionHeight : DEFAULT_TASK_POSITION_CONFIG.headerHeight;
+    let currentY = headerHeight + DEFAULT_TASK_POSITION_CONFIG.contentPaddingTop + DEFAULT_TASK_POSITION_CONFIG.stageBorderThickness;
+    for (const group of taskIds){
+        const isParallel = group.length > 1;
+        for(let taskIndex = 0; taskIndex < group.length; taskIndex++){
+            const taskId = group[taskIndex];
+            if (!taskId) continue;
+            const execution = taskRecord[taskId]?.execution;
+            const taskHeight = execution ? DEFAULT_TASK_POSITION_CONFIG.taskHeight + calculateExecutionExtraHeight(execution) : DEFAULT_TASK_POSITION_CONFIG.taskHeight;
+            positions.set(taskId, {
+                x: isParallel ? DEFAULT_TASK_POSITION_CONFIG.contentPaddingX + DEFAULT_TASK_POSITION_CONFIG.parallelIndent : DEFAULT_TASK_POSITION_CONFIG.contentPaddingX,
+                y: currentY,
+                width: isParallel ? parallelTaskWidth : taskWidth
+            });
+            currentY += taskHeight;
+            if (taskIndex < group.length - 1) currentY += DEFAULT_TASK_POSITION_CONFIG.taskGap;
+        }
+        currentY += DEFAULT_TASK_POSITION_CONFIG.taskGap;
+    }
+    return positions;
+}
+function calculateStageContentHeight(taskIds, taskData) {
+    const taskRecord = {};
+    if (taskData) if (Array.isArray(taskData)) taskData.forEach((node)=>{
+        taskRecord[node.id] = {
+            execution: node.data?.execution
+        };
+    });
+    else Object.assign(taskRecord, taskData);
+    let height = DEFAULT_TASK_POSITION_CONFIG.contentPaddingTop;
+    for (const group of taskIds)for (const taskId of group){
+        const execution = taskRecord[taskId]?.execution;
+        const taskHeight = execution ? DEFAULT_TASK_POSITION_CONFIG.taskHeight + calculateExecutionExtraHeight(execution) : DEFAULT_TASK_POSITION_CONFIG.taskHeight;
+        height += taskHeight + DEFAULT_TASK_POSITION_CONFIG.taskGap;
+    }
+    if (taskIds.length > 0) {
+        height -= DEFAULT_TASK_POSITION_CONFIG.taskGap;
+        height += DEFAULT_TASK_POSITION_CONFIG.contentPaddingBottom;
+    }
+    return height;
+}
+function useTaskPositions(taskIds, stageWidth, stageExecution) {
+    const positions = useMemo(()=>calculateTaskPositions(taskIds, stageWidth, void 0, stageExecution), [
+        taskIds,
+        stageWidth,
+        stageExecution
+    ]);
+    const contentHeight = useMemo(()=>calculateStageContentHeight(taskIds, void 0), [
+        taskIds
+    ]);
+    const getPosition = useCallback((taskId)=>positions.get(taskId), [
+        positions
+    ]);
+    const isParallel = useCallback((taskId)=>{
+        for (const group of taskIds)if (group.includes(taskId)) return group.length > 1;
+        return false;
+    }, [
+        taskIds
+    ]);
+    const getGroupInfo = useCallback((taskId)=>{
+        for(let groupIndex = 0; groupIndex < taskIds.length; groupIndex++){
+            const group = taskIds[groupIndex];
+            if (!group) continue;
+            const taskIndex = group.indexOf(taskId);
+            if (-1 !== taskIndex) return {
+                groupIndex,
+                taskIndex
+            };
+        }
+        return null;
+    }, [
+        taskIds
+    ]);
+    return {
+        positions,
+        contentHeight,
+        getPosition,
+        isParallel,
+        getGroupInfo
+    };
+}
+export { DEFAULT_TASK_POSITION_CONFIG, calculateStageContentHeight, calculateTaskPositions, useTaskPositions };

package/dist/canvas/core/TaskTypeRegistry.cjs

@@ -0,0 +1,132 @@
+"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__, {
+    TaskTypeRegistry: ()=>TaskTypeRegistry
+});
+class TaskTypeRegistry {
+    taskByType = new Map();
+    tasksByCategory = new Map();
+    registerTaskManifests(tasks) {
+        this.taskByType.clear();
+        this.tasksByCategory.clear();
+        for (const task of tasks){
+            this.taskByType.set(task.taskType, task);
+            const categoryKey = task.category;
+            const categoryTasks = this.tasksByCategory.get(categoryKey) ?? [];
+            categoryTasks.push(task);
+            this.tasksByCategory.set(categoryKey, categoryTasks);
+        }
+        for (const [key, categoryTasks] of this.tasksByCategory.entries()){
+            categoryTasks.sort((a, b)=>a.sortOrder - b.sortOrder);
+            this.tasksByCategory.set(key, categoryTasks);
+        }
+    }
+    getManifest(taskType) {
+        return this.taskByType.get(taskType);
+    }
+    getAllManifests() {
+        return Array.from(this.taskByType.values());
+    }
+    getAllTaskTypes() {
+        return Array.from(this.taskByType.keys());
+    }
+    isTaskAllowedInStage(taskType, stageNodeType) {
+        const manifest = this.getManifest(taskType);
+        if (!manifest) return false;
+        if (!manifest.allowedStageTypes || 0 === manifest.allowedStageTypes.length) return true;
+        return manifest.allowedStageTypes.includes(stageNodeType);
+    }
+    getTaskOptionsForStage(stageNodeType, iconResolver) {
+        const options = [];
+        for (const manifest of this.taskByType.values())if (this.isTaskAllowedInStage(manifest.taskType, stageNodeType)) options.push({
+            id: manifest.taskType,
+            name: manifest.display.label,
+            description: manifest.display.description,
+            icon: iconResolver ? {
+                Component: ()=>iconResolver(manifest.display.icon) ?? null
+            } : void 0,
+            section: manifest.category,
+            data: {
+                taskType: manifest.taskType,
+                defaultProperties: manifest.defaultProperties
+            }
+        });
+        return options.sort((a, b)=>{
+            const catA = a.section ?? '';
+            const catB = b.section ?? '';
+            if (catA !== catB) return catA.localeCompare(catB);
+            const manifestA = this.taskByType.get(a.id);
+            const manifestB = this.taskByType.get(b.id);
+            return (manifestA?.sortOrder ?? 0) - (manifestB?.sortOrder ?? 0);
+        });
+    }
+    getTasksByCategory(stageNodeType) {
+        if (!stageNodeType) return this.tasksByCategory;
+        const filtered = new Map();
+        for (const [category, tasks] of this.tasksByCategory.entries()){
+            const allowedTasks = tasks.filter((t)=>this.isTaskAllowedInStage(t.taskType, stageNodeType));
+            if (allowedTasks.length > 0) filtered.set(category, allowedTasks);
+        }
+        return filtered;
+    }
+    searchTasks(query, stageNodeType) {
+        const lowerQuery = query.toLowerCase();
+        const results = [];
+        for (const manifest of this.taskByType.values())if (!stageNodeType || this.isTaskAllowedInStage(manifest.taskType, stageNodeType)) {
+            if (manifest.display.label.toLowerCase().includes(lowerQuery)) {
+                results.push(manifest);
+                continue;
+            }
+            if (manifest.display.description?.toLowerCase().includes(lowerQuery)) {
+                results.push(manifest);
+                continue;
+            }
+            if (manifest.tags.some((tag)=>tag.toLowerCase().includes(lowerQuery))) results.push(manifest);
+        }
+        return results.sort((a, b)=>a.sortOrder - b.sortOrder);
+    }
+    createDefaultTaskData(taskType) {
+        const manifest = this.getManifest(taskType);
+        if (!manifest) return;
+        return {
+            taskType: manifest.taskType,
+            label: manifest.display.label,
+            icon: manifest.display.icon,
+            ...manifest.defaultProperties ?? {}
+        };
+    }
+    clear() {
+        this.taskByType.clear();
+        this.tasksByCategory.clear();
+    }
+}
+exports.TaskTypeRegistry = __webpack_exports__.TaskTypeRegistry;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "TaskTypeRegistry"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/core/TaskTypeRegistry.d.ts

@@ -0,0 +1,18 @@
+import type { ListItem } from '../components';
+import type { TaskManifest } from '../schema/task-definition';
+export type TaskIconResolver = (iconId: string) => React.ReactElement | undefined;
+export declare class TaskTypeRegistry {
+    private taskByType;
+    private tasksByCategory;
+    registerTaskManifests(tasks: TaskManifest[]): void;
+    getManifest(taskType: string): TaskManifest | undefined;
+    getAllManifests(): TaskManifest[];
+    getAllTaskTypes(): string[];
+    isTaskAllowedInStage(taskType: string, stageNodeType: string): boolean;
+    getTaskOptionsForStage(stageNodeType: string, iconResolver?: TaskIconResolver): ListItem[];
+    getTasksByCategory(stageNodeType?: string): Map<string | undefined, TaskManifest[]>;
+    searchTasks(query: string, stageNodeType?: string): TaskManifest[];
+    createDefaultTaskData(taskType: string): Record<string, unknown> | undefined;
+    clear(): void;
+}
+//# sourceMappingURL=TaskTypeRegistry.d.ts.map

package/dist/canvas/core/TaskTypeRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskTypeRegistry.d.ts","sourceRoot":"","sources":["../../../src/canvas/core/TaskTypeRegistry.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAK9D,MAAM,MAAM,gBAAgB,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,KAAK,CAAC,YAAY,GAAG,SAAS,CAAC;AAMlF,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,UAAU,CAAmC;IACrD,OAAO,CAAC,eAAe,CAAiD;IAOxE,qBAAqB,CAAC,KAAK,EAAE,YAAY,EAAE,GAAG,IAAI;IA6BlD,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IASvD,eAAe,IAAI,YAAY,EAAE;IASjC,eAAe,IAAI,MAAM,EAAE;IAW3B,oBAAoB,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO;IAmBtE,sBAAsB,CACpB,aAAa,EAAE,MAAM,EACrB,YAAY,CAAC,EAAE,gBAAgB,GAC9B,QAAQ,EAAE;IAyCb,kBAAkB,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,GAAG,SAAS,EAAE,YAAY,EAAE,CAAC;IAyBnF,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,YAAY,EAAE;IAqClE,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS;IAe5E,KAAK,IAAI,IAAI;CAId"}

package/dist/canvas/core/TaskTypeRegistry.js

@@ -0,0 +1,98 @@
+class TaskTypeRegistry {
+    taskByType = new Map();
+    tasksByCategory = new Map();
+    registerTaskManifests(tasks) {
+        this.taskByType.clear();
+        this.tasksByCategory.clear();
+        for (const task of tasks){
+            this.taskByType.set(task.taskType, task);
+            const categoryKey = task.category;
+            const categoryTasks = this.tasksByCategory.get(categoryKey) ?? [];
+            categoryTasks.push(task);
+            this.tasksByCategory.set(categoryKey, categoryTasks);
+        }
+        for (const [key, categoryTasks] of this.tasksByCategory.entries()){
+            categoryTasks.sort((a, b)=>a.sortOrder - b.sortOrder);
+            this.tasksByCategory.set(key, categoryTasks);
+        }
+    }
+    getManifest(taskType) {
+        return this.taskByType.get(taskType);
+    }
+    getAllManifests() {
+        return Array.from(this.taskByType.values());
+    }
+    getAllTaskTypes() {
+        return Array.from(this.taskByType.keys());
+    }
+    isTaskAllowedInStage(taskType, stageNodeType) {
+        const manifest = this.getManifest(taskType);
+        if (!manifest) return false;
+        if (!manifest.allowedStageTypes || 0 === manifest.allowedStageTypes.length) return true;
+        return manifest.allowedStageTypes.includes(stageNodeType);
+    }
+    getTaskOptionsForStage(stageNodeType, iconResolver) {
+        const options = [];
+        for (const manifest of this.taskByType.values())if (this.isTaskAllowedInStage(manifest.taskType, stageNodeType)) options.push({
+            id: manifest.taskType,
+            name: manifest.display.label,
+            description: manifest.display.description,
+            icon: iconResolver ? {
+                Component: ()=>iconResolver(manifest.display.icon) ?? null
+            } : void 0,
+            section: manifest.category,
+            data: {
+                taskType: manifest.taskType,
+                defaultProperties: manifest.defaultProperties
+            }
+        });
+        return options.sort((a, b)=>{
+            const catA = a.section ?? '';
+            const catB = b.section ?? '';
+            if (catA !== catB) return catA.localeCompare(catB);
+            const manifestA = this.taskByType.get(a.id);
+            const manifestB = this.taskByType.get(b.id);
+            return (manifestA?.sortOrder ?? 0) - (manifestB?.sortOrder ?? 0);
+        });
+    }
+    getTasksByCategory(stageNodeType) {
+        if (!stageNodeType) return this.tasksByCategory;
+        const filtered = new Map();
+        for (const [category, tasks] of this.tasksByCategory.entries()){
+            const allowedTasks = tasks.filter((t)=>this.isTaskAllowedInStage(t.taskType, stageNodeType));
+            if (allowedTasks.length > 0) filtered.set(category, allowedTasks);
+        }
+        return filtered;
+    }
+    searchTasks(query, stageNodeType) {
+        const lowerQuery = query.toLowerCase();
+        const results = [];
+        for (const manifest of this.taskByType.values())if (!stageNodeType || this.isTaskAllowedInStage(manifest.taskType, stageNodeType)) {
+            if (manifest.display.label.toLowerCase().includes(lowerQuery)) {
+                results.push(manifest);
+                continue;
+            }
+            if (manifest.display.description?.toLowerCase().includes(lowerQuery)) {
+                results.push(manifest);
+                continue;
+            }
+            if (manifest.tags.some((tag)=>tag.toLowerCase().includes(lowerQuery))) results.push(manifest);
+        }
+        return results.sort((a, b)=>a.sortOrder - b.sortOrder);
+    }
+    createDefaultTaskData(taskType) {
+        const manifest = this.getManifest(taskType);
+        if (!manifest) return;
+        return {
+            taskType: manifest.taskType,
+            label: manifest.display.label,
+            icon: manifest.display.icon,
+            ...manifest.defaultProperties ?? {}
+        };
+    }
+    clear() {
+        this.taskByType.clear();
+        this.tasksByCategory.clear();
+    }
+}
+export { TaskTypeRegistry };

package/dist/canvas/core/index.cjs

@@ -12,8 +12,14 @@ var __webpack_modules__ = {
     "./NodeTypeRegistry": function(module) {
         module.exports = require("./NodeTypeRegistry.cjs");
     },
+    "./TaskTypeRegistry": function(module) {
+        module.exports = require("./TaskTypeRegistry.cjs");
+    },
     "./useNodeTypeRegistry": function(module) {
         module.exports = require("./useNodeTypeRegistry.cjs");
+    },
+    "./useTaskTypeRegistry": function(module) {
+        module.exports = require("./useTaskTypeRegistry.cjs");
     }
 };
 var __webpack_module_cache__ = {};
@@ -83,10 +89,22 @@ var __webpack_exports__ = {};
         return _NodeTypeRegistry__WEBPACK_IMPORTED_MODULE_3__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _useNodeTypeRegistry__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("./useNodeTypeRegistry");
+    var _TaskTypeRegistry__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("./TaskTypeRegistry");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _TaskTypeRegistry__WEBPACK_IMPORTED_MODULE_4__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _TaskTypeRegistry__WEBPACK_IMPORTED_MODULE_4__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _useNodeTypeRegistry__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__("./useNodeTypeRegistry");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _useNodeTypeRegistry__WEBPACK_IMPORTED_MODULE_5__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _useNodeTypeRegistry__WEBPACK_IMPORTED_MODULE_5__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _useTaskTypeRegistry__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__("./useTaskTypeRegistry");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _useNodeTypeRegistry__WEBPACK_IMPORTED_MODULE_4__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _useNodeTypeRegistry__WEBPACK_IMPORTED_MODULE_4__[key];
+    for(var __WEBPACK_IMPORT_KEY__ in _useTaskTypeRegistry__WEBPACK_IMPORTED_MODULE_6__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _useTaskTypeRegistry__WEBPACK_IMPORTED_MODULE_6__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
 })();

package/dist/canvas/core/index.d.ts

@@ -2,5 +2,7 @@ export * from './CategoryTree';
 export * from './CategoryTreeAdapter';
 export * from './NodeRegistryProvider';
 export * from './NodeTypeRegistry';
+export * from './TaskTypeRegistry';
 export * from './useNodeTypeRegistry';
+export * from './useTaskTypeRegistry';
 //# sourceMappingURL=index.d.ts.map

package/dist/canvas/core/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/canvas/core/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/canvas/core/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC"}

package/dist/canvas/core/index.js

@@ -2,4 +2,6 @@ export * from "./CategoryTree.js";
 export * from "./CategoryTreeAdapter.js";
 export * from "./NodeRegistryProvider.js";
 export * from "./NodeTypeRegistry.js";
+export * from "./TaskTypeRegistry.js";
 export * from "./useNodeTypeRegistry.js";
+export * from "./useTaskTypeRegistry.js";