@camunda/task-testing 2.0.1 → 2.2.0

package/dist/types/ElementConfig.d.ts

@@ -0,0 +1,32 @@
+export namespace DEFAULT_CONFIG {
+    let input: {};
+    let output: {};
+}
+export class ElementConfig extends EventEmitter<[never]> {
+    constructor(injector: any, elementVariables: any, config?: {
+        input: {};
+        output: {};
+    });
+    _injector: any;
+    _elementVariables: any;
+    /**
+     * @type {import('./types').Config}
+     */
+    _config: import("./types").Config;
+    _selectedElement: any;
+    _variablesForElements: Map<any, any>;
+    setConfig(newConfig: any): void;
+    getConfig(): import("./types").Config;
+    setInputConfigForElement(element: any, newConfig: any): void;
+    resetInputConfigForElement(element: any): void;
+    setOutputConfigForElement(element: any, newConfig: any): void;
+    resetOutputConfigForElement(element: any): void;
+    getInputConfigForElement(element: any): string;
+    /**
+     * @param {import('./types').Element} element
+     * @returns {import('./types').ElementOutput}
+     */
+    getOutputConfigForElement(element: import("./types").Element): import("./types").ElementOutput;
+    _getDefaultInputConfig(): string;
+}
+import EventEmitter from 'events';

package/dist/types/ElementVariables.d.ts

@@ -0,0 +1,8 @@
+export class ElementVariables extends EventEmitter<[never]> {
+    constructor(injector: any);
+    _injector: any;
+    _variables: {};
+    _variableResolver: any;
+    getVariablesForElement(element: any): Promise<any>;
+}
+import EventEmitter from 'events';

package/dist/types/TaskExecution.d.ts

@@ -0,0 +1,67 @@
+/**
+ *
+ * @param {import('./types').VariableSearchResult[]} getVariablesResponseItems
+ * @param {import('./types').ElementInstanceResult[]} getElementInstancesResponseItems
+ * @param {import('./types').ProcessInstanceResult} processInstance
+ * @param elementId
+ * @returns {object}
+ */
+export function getVariables(getVariablesResponseItems: import("./types").VariableSearchResult[], getElementInstancesResponseItems: import("./types").ElementInstanceResult[], processInstance: import("./types").ProcessInstanceResult, elementId: any): object;
+/**
+ * Get the process definition key from the deployment response.
+ *
+ * @param {import('./types').ExtendedDeploymentResult} deployResponse
+ * @param {string} processId
+ *
+ * @returns {string | null}
+ */
+export function getProcessDefinitionKey(deployResponse: import("./types").ExtendedDeploymentResult, processId: string): string | null;
+export const INTERVAL_MS: 1000;
+export namespace SCOPES {
+    let LOCAL: string;
+    let PROCESS: string;
+}
+/**
+ * Emits:
+ * - `taskExecution.status.changed` with one of {@link TaskExecutionStatus}
+ * - `taskExecution.finished` with {@link TaskExecutionResult}
+ * - `taskExecution.error` with {@link TaskExecutionError}
+ * - `taskExecution.interrupted` when execution is interrupted by switching focus
+ */
+export default class TaskExecution extends EventEmitter<[never]> {
+    /**
+     * @param {import('didi').Injector} injector
+     * @param {TaskExecutionApi} api
+     */
+    constructor(injector: import("didi").Injector, api: TaskExecutionApi);
+    /** @type {TaskExecutionApi} */
+    _api: TaskExecutionApi;
+    _interval: NodeJS.Timeout | null;
+    /** @type {TaskExecutionStatus} */
+    _status: TaskExecutionStatus;
+    /**
+     * Start task execution.
+     *
+     * @param {import('./types').Element} element
+     * @param {Object} variables
+     *
+     * @returns {Promise<void>}
+     */
+    executeTask(element: import("./types").Element, variables: any): Promise<void>;
+    /**
+     * Cancel current task execution, clean up and change status to `idle`.
+     */
+    cancelTaskExecution(): Promise<void>;
+    /**
+     * Emit `taskExecution.error` event.
+     *
+     * @param {string} message
+     * @param {any} [response]
+     */
+    _emitError(message: string, response?: any): void;
+    /** @param {TaskExecutionStatus} status */
+    _changeStatus(status: TaskExecutionStatus, ...args: any[]): void;
+}
+import EventEmitter from 'events';
+import type { TaskExecutionApi } from './types';
+import type { TaskExecutionStatus } from './types';

package/dist/types/components/Input/Input.d.ts

@@ -0,0 +1,8 @@
+export default function Input({ allOutputs, input, onErrorChange, onResetInput, onSetInput, variablesForElement }: {
+    allOutputs: any;
+    input?: string | undefined;
+    onErrorChange: any;
+    onResetInput: any;
+    onSetInput: any;
+    variablesForElement: any;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Input/InputEditor.d.ts

@@ -0,0 +1,9 @@
+export default function InputEditor({ allOutputs, value, onChange, onErrorChange, variablesForElement }: {
+    allOutputs?: {} | undefined;
+    value: any;
+    onChange: any;
+    onErrorChange: any;
+    variablesForElement?: any[] | undefined;
+}): import("react/jsx-runtime").JSX.Element;
+export const PLACEHOLDER_TEXT: "Enter process variables in JSON format";
+export const INVALID_JSON_ERROR: "JSON contains errors";

package/dist/types/components/Output/Output.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @param {Object} props
+ * @param {import('bpmn-js/lib/model/Types').Element} props.element
+ * @param {boolean} props.isConnectionConfigured
+ * @param {string} props.configureConnectionBannerTitle
+ * @param {string} props.configureConnectionBannerDescription
+ * @param {string} props.configureConnectionLabel
+ * @param {string|undefined} props.currentOperateUrl
+ * @param {Function} [props.onConfigureConnection]
+ * @param {boolean} props.isTaskExecuting
+ * @param {import('../../types').ElementOutput} props.output
+ * @param {Function} props.onResetOutput
+ * @param {import('../../types').TaskExecutionStatus} props.taskExecutionStatus
+ */
+export default function Output({ element, isConnectionConfigured, configureConnectionBannerTitle, configureConnectionBannerDescription, configureConnectionLabel, onConfigureConnection, isTaskExecuting, output, currentOperateUrl, onResetOutput, taskExecutionStatus }: {
+    element: import("bpmn-js/lib/model/Types").Element;
+    isConnectionConfigured: boolean;
+    configureConnectionBannerTitle: string;
+    configureConnectionBannerDescription: string;
+    configureConnectionLabel: string;
+    currentOperateUrl: string | undefined;
+    onConfigureConnection?: Function | undefined;
+    isTaskExecuting: boolean;
+    output: import("../../types").ElementOutput;
+    onResetOutput: Function;
+    taskExecutionStatus: import("../../types").TaskExecutionStatus;
+}): import("react/jsx-runtime").JSX.Element;
+export const TASK_EXECUTION_STATUS_LABEL: {
+    deploying: string;
+    'starting-instance': string;
+    executing: string;
+};
+export const NO_OPERATE_URL_TOOLTIP: "No Operate URL set for this connection";
+export function HeaderLink({ children, render, visible, href, target, className, onClick, role, tooltip, priority }: {
+    render?: ((props: any) => React.ReactNode) | undefined;
+    children?: React.ReactNode;
+    visible?: boolean | ((props: any) => boolean) | undefined;
+    href?: string | ((props: any) => string) | undefined;
+    target?: string | ((props: any) => string) | undefined;
+    className?: string | ((props: any) => string | undefined) | undefined;
+    onClick?: Function | ((props: any) => Function) | undefined;
+    role?: string | ((props: any) => string) | undefined;
+    tooltip?: string | ((props: any) => string | undefined) | undefined;
+    priority?: number | undefined;
+}): null;
+import React from 'react';

package/dist/types/components/Output/OutputEditor.d.ts

@@ -0,0 +1,3 @@
+export default function OutputEditor({ value }: {
+    value: any;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Output/OutputVariables.d.ts

@@ -0,0 +1,20 @@
+export function OutputVariables({ isTaskExecuting, output, element }: {
+    isTaskExecuting: any;
+    output: any;
+    element: any;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Pick variables for a given scope. Variables in legacy format are ignored.
+ *
+ * @param {import('../../types').ElementOutputVariables} variables
+ * @param {string} scope
+ *
+ * @returns {Object}
+ */
+export function pickVariables(variables: import("../../types").ElementOutputVariables, scope: string): any;
+export function OutputTab({ children, render, label, priority }: {
+    label: string;
+    render?: Function | undefined;
+    children?: React.ReactNode;
+    priority?: number | undefined;
+}): null;

package/dist/types/components/TaskTesting/TaskTesting.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @param {Object} props
+ * @param {Object} props.injector
+ * @param {import('../../types').TaskExecutionApi} props.api
+ * @param {boolean} props.isConnectionConfigured
+ * @param {string} [props.configureConnectionBannerTitle]
+ * @param {string} [props.configureConnectionBannerDescription]
+ * @param {string} [props.configureConnectionLabel]
+ * @param {Function} [props.onConfigureConnection] - Callback invoked when
+ * the user clicks on the _Configure connection_ button.
+ * @param {(() => boolean | Promise<boolean>)} [props.onTestTask] - Callback invoked when the user clicks
+ * on the _Test task_ button. Should return `true` to proceed with task
+ * execution or `false` to abort it. Can return a promise resolving to a
+ * boolean.
+ * @param {import('../../types').Config|undefined} [props.config]
+ * @param {Function} [props.onConfigChanged=() => {}]
+ * @param {string} [props.operateBaseUrl]
+ * @param {string} [props.documentationUrl]
+ * @param {Function} [props.onTaskExecutionStarted=() => {}]
+ * @param {Function} [props.onTaskExecutionFinished=() => {}]
+ * @param {Function} [props.onTaskExecutionInterrupted=() => {}]
+ * @param {React.ReactNode[]} [props.children=[]]
+ */
+declare function TaskTesting({ injector, api, isConnectionConfigured, configureConnectionBannerTitle, configureConnectionBannerDescription, configureConnectionLabel, onConfigureConnection, onTestTask, config, onConfigChanged, operateBaseUrl, documentationUrl, onTaskExecutionStarted, onTaskExecutionFinished, onTaskExecutionInterrupted, children }: {
+    injector: any;
+    api: import("../../types").TaskExecutionApi;
+    isConnectionConfigured: boolean;
+    configureConnectionBannerTitle?: string | undefined;
+    configureConnectionBannerDescription?: string | undefined;
+    configureConnectionLabel?: string | undefined;
+    onConfigureConnection?: Function | undefined;
+    onTestTask?: (() => boolean | Promise<boolean>) | undefined;
+    config?: import("../../types").Config | undefined;
+    onConfigChanged?: Function | undefined;
+    operateBaseUrl?: string | undefined;
+    documentationUrl?: string | undefined;
+    onTaskExecutionStarted?: Function | undefined;
+    onTaskExecutionFinished?: Function | undefined;
+    onTaskExecutionInterrupted?: Function | undefined;
+    children?: React.ReactNode[] | undefined;
+}): import("react/jsx-runtime").JSX.Element;
+declare namespace TaskTesting {
+    export { OutputTab as Tab };
+    export { HeaderLink as Link };
+}
+export default TaskTesting;
+import React from 'react';
+import { OutputTab } from '../Output/OutputVariables';
+import { HeaderLink } from '../Output/Output';

package/dist/types/components/shared/CodeMirrorTheme.d.ts

@@ -0,0 +1,5 @@
+export const baseTheme: import("@codemirror/state").Extension;
+export const highlightTheme: import("@codemirror/state").Extension;
+export const syntaxClasses: import("@codemirror/state").Extension;
+declare const _default: import("@codemirror/state").Extension[];
+export default _default;

package/dist/types/components/shared/plugins.d.ts

@@ -0,0 +1,4 @@
+export const PluginContext: import("react").Context<import("../../types").PluginContextValue>;
+export function usePluginsProviderValue(defaultValue?: Plugin[]): PluginContextValue;
+export type Plugin = import("../../types").Plugin;
+export type PluginContextValue = import("../../types").PluginContextValue;

package/dist/types/hooks/useSelectedElement.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Get currently selected BPMN element, if it is a single `bpmn:Task`. If not,
+ * return null and a message indicating what to do.
+ *
+ * @param {Object} injector
+ * @return {[ Object|null, string|null ]}
+ */
+export function useSelectedElement(injector: any): [any | null, string | null];
+export const SINGLE_TASK_SELECTION_REQUIRED_MESSAGE: "Select a task to start testing.";
+export const TASK_SELECTION_REQUIRED_MESSAGE: "Task testing is only supported for tasks. Select a task to start testing.";
+export const AD_HOC_SUBPROCESS_TASK_UNSUPPORTED_MESSAGE: "Task testing is not supported for tasks inside an ad-hoc subprocess. Select a different task to start testing.";

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./components/TaskTesting/TaskTesting";

package/dist/types/types.d.ts

@@ -0,0 +1,81 @@
+import type { CamundaClient, CreateProcessInstanceResult, ElementInstanceResult, ElementInstanceSearchQueryResult, IncidentResult, IncidentSearchQueryResult, ProcessInstanceResult, ProcessInstanceSearchQueryResult, ProcessInstanceStateEnum, VariableSearchQueryResult, VariableSearchResult } from '@camunda8/orchestration-cluster-api';
+import type { ModdleElement } from "bpmn-js/lib/model/Types";
+type ExtendedDeploymentResult = Awaited<ReturnType<CamundaClient['createDeployment']>>;
+export type { CreateProcessInstanceResult, ElementInstanceSearchQueryResult, IncidentSearchQueryResult, ProcessInstanceSearchQueryResult, ProcessInstanceResult, VariableSearchQueryResult, ExtendedDeploymentResult, ProcessInstanceStateEnum, VariableSearchResult, ElementInstanceResult, IncidentResult };
+export type Input = {
+    [elementId: string]: string;
+};
+export type Output = {
+    [elementId: string]: ElementOutput;
+};
+export type VARIABLE_SCOPE = 'LOCAL' | 'PROCESS';
+export type ElementOutputVariables = {
+    [id: string]: {
+        name: string;
+        value: any;
+        scope: VARIABLE_SCOPE;
+    };
+};
+export type ElementOutput = {
+    success: boolean;
+    variables?: ElementOutputVariables;
+    error?: TaskExecutionError;
+    incident?: any;
+    operateUrl?: string;
+    [key: string]: any;
+} | undefined;
+export type Config = {
+    input: Input;
+    output: Output;
+};
+export type Variable = {
+    name: string;
+    type?: string;
+    info?: string;
+    isList?: boolean;
+    entries?: Variable[];
+    scope?: ModdleElement;
+};
+export type Variables = Variable[];
+export type ApiResponse<T> = {
+    success: true;
+    response: T;
+} | {
+    success: false;
+    error: string;
+};
+export type TaskExecutionApi = {
+    deploy: () => Promise<ApiResponse<ExtendedDeploymentResult>>;
+    startInstance: (processDefinitionKey: string, elementId: string, variables: {
+        [key: string]: any;
+    }) => Promise<ApiResponse<CreateProcessInstanceResult>>;
+    getProcessInstance: (processInstanceKey: string) => Promise<ApiResponse<ProcessInstanceSearchQueryResult>>;
+    getProcessInstanceVariables: (processInstanceKey: string) => Promise<ApiResponse<VariableSearchQueryResult>>;
+    getProcessInstanceElementInstances: (processInstanceKey: string) => Promise<ApiResponse<ElementInstanceSearchQueryResult>>;
+    getProcessInstanceIncident: (processInstanceKey: string) => Promise<ApiResponse<IncidentSearchQueryResult>>;
+};
+export type TaskExecutionStatus = 'idle' | 'deploying' | 'starting-instance' | 'executing';
+export type TaskExecutionEvents = 'taskExecution.status.changed' | 'taskExecution.finished' | 'taskExecution.error' | 'taskExecution.interrupted';
+export type TaskExecutionResult = {
+    success: boolean;
+    variables?: ElementOutputVariables;
+    error?: TaskExecutionError;
+    incident?: any;
+};
+export type TaskExecutionError = {
+    message: string;
+    response?: any;
+};
+export type { Element, ModdleElement } from 'bpmn-js/lib/model/Types';
+export type Plugin = {
+    priority?: number;
+    render: Function;
+    type: string;
+    [key: string]: any;
+};
+export type PluginContextValue = {
+    plugins: Plugin[];
+    registerPlugin: (plugin: Plugin) => void;
+    unregisterPlugin: (plugin: Plugin) => void;
+    getPlugins: (pluginPoint: string) => Plugin[];
+};

package/dist/types/utils/autocompletion.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @typedef {import('@codemirror/autocomplete').Completion} Completion
+ * @typedef {import('@codemirror/autocomplete').CompletionContext} CompletionContext
+ * @typedef {import('@codemirror/autocomplete').CompletionResult} CompletionResult
+ */
+/**
+ * @param {Completion[]} variables
+ */
+export function getAutocompletionExtensions(variables: Completion[]): import("@codemirror/state").Extension[];
+export type Completion = import("@codemirror/autocomplete").Completion;
+export type CompletionContext = import("@codemirror/autocomplete").CompletionContext;
+export type CompletionResult = import("@codemirror/autocomplete").CompletionResult;

package/dist/types/utils/element.d.ts

@@ -0,0 +1,11 @@
+export function getName(element: any): string;
+export function getType(element: any, injector: any): any;
+export function getConcreteType(element: any): any;
+/**
+ * Get parent process of an element.
+ *
+ * @param {import('../types').Element} element
+ *
+ * @returns {string|null}
+ */
+export function getProcessId(element: import("../types").Element): string | null;

package/dist/types/utils/getOperateUrl.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {string} operateBaseUrl
+ * @param {string} processInstanceKey
+ * @returns {string}
+ */
+export function getOperateUrl(operateBaseUrl: string, processInstanceKey: string): string;

package/package.json

@@ -1,95 +1,99 @@
-{
-  "name": "@camunda/task-testing",
-  "version": "2.0.1",
-  "files": [
-    "dist"
-  ],
-  "main": "dist/index.js",
-  "scripts": {
-    "all": "run-s lint types test build",
-    "open": "open-cli http://localhost:3000",
-    "start:server": "node demo/server.mjs",
-    "start:client": "webpack --watch --config webpack.demo.js",
-    "start": "run-p start:* open",
-    "dev": "npm test -- --auto-watch --no-single-run",
-    "build": "webpack",
-    "build:watch": "webpack --watch",
-    "build:demo": "webpack --config webpack.demo.js",
-    "test": "karma start karma.config.js",
-    "lint": "eslint .",
-    "types": "tsc --noEmit",
-    "prepare": "npm run build"
-  },
-  "license": "MIT",
-  "dependencies": {
-    "@codemirror/autocomplete": "^6.19.1",
-    "@codemirror/lang-json": "^6.0.2",
-    "@codemirror/language": "^6.11.3",
-    "@codemirror/state": "^6.5.2",
-    "@codemirror/view": "^6.38.8",
-    "@lezer/highlight": "^1.2.1",
-    "classnames": "^2.5.1",
-    "codemirror": "^6.0.2",
-    "events": "^3.3.0",
-    "min-dash": "^4.2.3"
-  },
-  "devDependencies": {
-    "@babel/core": "^7.28.0",
-    "@babel/preset-env": "^7.28.0",
-    "@babel/preset-react": "^7.27.1",
-    "@bpmn-io/variable-resolver": "^1.3.6",
-    "@camunda8/sdk": "^8.8.3",
-    "@carbon/icons-react": "^11.62.0",
-    "@carbon/react": "^1.76.0",
-    "@eslint/js": "^9.31.0",
-    "@testing-library/react": "^16.3.0",
-    "@testing-library/user-event": "^14.6.1",
-    "@types/codemirror": "^5.60.16",
-    "@types/react": "^19.1.12",
-    "babel-loader": "^10.0.0",
-    "bpmn-js-element-templates": "^2.15.1",
-    "bpmn-js-headless": "^0.1.0",
-    "bpmn-js-properties-panel": "^5.42.3",
-    "camunda-bpmn-js": "^5.14.2",
-    "chai": "^4.5.0",
-    "css-loader": "^7.1.2",
-    "dotenv": "^17.2.1",
-    "eslint": "^9.31.0",
-    "eslint-plugin-bpmn-io": "^2.2.0",
-    "eslint-plugin-react-hooks": "^5.2.0",
-    "eslint-plugin-react-refresh": "^0.4.20",
-    "express": "^5.1.0",
-    "html-webpack-plugin": "^5.6.3",
-    "karma": "^6.4.4",
-    "karma-chrome-launcher": "^3.2.0",
-    "karma-env-preprocessor": "^0.1.1",
-    "karma-mocha": "^2.0.1",
-    "karma-sinon-chai": "^2.0.2",
-    "karma-webpack": "^5.0.1",
-    "mocha": "^11.7.1",
-    "npm-run-all2": "^8.0.4",
-    "open": "^10.2.0",
-    "open-cli": "^8.0.0",
-    "raw-loader": "^4.0.2",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
-    "sass": "^1.89.2",
-    "sass-loader": "^16.0.5",
-    "sinon": "^17.0.1",
-    "sinon-chai": "^3.7.0",
-    "style-loader": "^4.0.0",
-    "typescript": "^5.9.2",
-    "webpack": "^5.100.1",
-    "webpack-cli": "^6.0.1",
-    "webpack-dev-server": "^5.2.2",
-    "zeebe-bpmn-moddle": "^1.11.0"
-  },
-  "peerDependencies": {
-    "camunda-bpmn-js": "*",
-    "react": "*",
-    "react-dom": "*"
-  },
-  "overrides": {
-    "react-is": "^18.0.0"
-  }
-}
+{
+  "name": "@camunda/task-testing",
+  "version": "2.2.0",
+  "files": [
+    "dist"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/types/index.d.ts",
+  "scripts": {
+    "all": "run-s lint types test build",
+    "open": "open-cli http://localhost:3000",
+    "start:server": "node demo/server.mjs",
+    "start:client": "webpack --watch --config webpack.demo.js",
+    "start": "run-p start:* open",
+    "dev": "npm test -- --auto-watch --no-single-run",
+    "build": "run-s build:webpack build:types",
+    "build:webpack": "webpack",
+    "build:watch": "webpack --watch",
+    "build:demo": "webpack --config webpack.demo.js",
+    "build:types": "tsc",
+    "test": "karma start karma.config.js",
+    "lint": "eslint .",
+    "types": "tsc --noEmit",
+    "prepare": "npm run build"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@codemirror/autocomplete": "^6.19.1",
+    "@codemirror/lang-json": "^6.0.2",
+    "@codemirror/language": "^6.11.3",
+    "@codemirror/state": "^6.5.2",
+    "@codemirror/view": "^6.38.8",
+    "@lezer/highlight": "^1.2.1",
+    "classnames": "^2.5.1",
+    "codemirror": "^6.0.2",
+    "events": "^3.3.0",
+    "min-dash": "^4.2.3"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.28.0",
+    "@babel/preset-env": "^7.28.0",
+    "@babel/preset-react": "^7.27.1",
+    "@bpmn-io/variable-resolver": "^1.3.6",
+    "@camunda8/orchestration-cluster-api": "^8.8.4",
+    "@camunda8/sdk": "^8.8.3",
+    "@carbon/icons-react": "^11.62.0",
+    "@carbon/react": "^1.76.0",
+    "@eslint/js": "^9.31.0",
+    "@testing-library/react": "^16.3.0",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/codemirror": "^5.60.16",
+    "@types/react": "^19.1.12",
+    "babel-loader": "^10.0.0",
+    "bpmn-js-element-templates": "^2.15.1",
+    "bpmn-js-headless": "^0.1.0",
+    "bpmn-js-properties-panel": "^5.42.3",
+    "camunda-bpmn-js": "^5.14.2",
+    "chai": "^4.5.0",
+    "css-loader": "^7.1.2",
+    "dotenv": "^17.2.1",
+    "eslint": "^9.31.0",
+    "eslint-plugin-bpmn-io": "^2.2.0",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "eslint-plugin-react-refresh": "^0.4.20",
+    "express": "^5.1.0",
+    "html-webpack-plugin": "^5.6.3",
+    "karma": "^6.4.4",
+    "karma-chrome-launcher": "^3.2.0",
+    "karma-env-preprocessor": "^0.1.1",
+    "karma-mocha": "^2.0.1",
+    "karma-sinon-chai": "^2.0.2",
+    "karma-webpack": "^5.0.1",
+    "mocha": "^11.7.1",
+    "npm-run-all2": "^8.0.4",
+    "open": "^10.2.0",
+    "open-cli": "^8.0.0",
+    "raw-loader": "^4.0.2",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "sass": "^1.89.2",
+    "sass-loader": "^16.0.5",
+    "sinon": "^17.0.1",
+    "sinon-chai": "^3.7.0",
+    "style-loader": "^4.0.0",
+    "typescript": "^5.9.2",
+    "webpack": "^5.100.1",
+    "webpack-cli": "^6.0.1",
+    "webpack-dev-server": "^5.2.2",
+    "zeebe-bpmn-moddle": "^1.11.0"
+  },
+  "peerDependencies": {
+    "camunda-bpmn-js": "*",
+    "react": "*",
+    "react-dom": "*"
+  },
+  "overrides": {
+    "react-is": "^18.0.0"
+  }
+}