@camunda/task-testing 3.0.0 → 4.0.0

package/dist/types/ElementConfig.d.ts

@@ -1,3 +1,4 @@
+export { DEFAULT_INPUT_CONFIG };
 export namespace DEFAULT_CONFIG {
     let input: {};
     let output: {};
@@ -13,8 +14,6 @@ export class ElementConfig extends EventEmitter<[never]> {
      * @type {Config}
      */
     _config: Config;
-    _selectedElement: any;
-    _variablesForElements: Map<any, any>;
     setConfig(newConfig: any): void;
     getConfig(): Config;
     setInputConfigForElement(element: any, newConfig: any): void;
@@ -22,13 +21,28 @@ export class ElementConfig extends EventEmitter<[never]> {
     setOutputConfigForElement(element: any, newConfig: any): void;
     resetOutputConfigForElement(element: any): void;
     getInputConfigForElement(element: any): string;
+    getDefaultInputForElement(element: any): Promise<string>;
+    /**
+     * Merges default input with already existing user edits.
+     *
+     * Returns null if the input config is unparsable to persist in progress edits
+     *
+     * @param {Element} element
+     * @returns {Promise<string|null>} merged JSON string, or null if current input is unparseable
+     */
+    getMergedInputConfigForElement(element: Element): Promise<string | null>;
     /**
      * @param {Element} element
      * @returns {ElementOutput}
      */
     getOutputConfigForElement(element: Element): ElementOutput;
-    _getDefaultInputConfig(): string;
+    /**
+     * @param {Object} element
+     * @throws {Error} if the element type is not supported
+     */
+    _assertSupportedElement(element: any): void;
 }
+import { DEFAULT_INPUT_CONFIG } from './utils/prefill';
 import EventEmitter from 'events';
 import type { Config } from './types';
 import type { Element } from './types';

package/dist/types/ElementVariables.d.ts

@@ -4,5 +4,6 @@ export class ElementVariables extends EventEmitter<[never]> {
     _variables: {};
     _variableResolver: any;
     getVariablesForElement(element: any): Promise<any>;
+    getConsumedVariablesForElement(element: any): Promise<any>;
 }
 import EventEmitter from 'events';

package/dist/types/ExecutionLog.d.ts

@@ -69,6 +69,98 @@ export function createFinishedStatusEntry(result: TaskExecutionFinishedResult, t
  * @returns {string}
  */
 export function formatElementType(type: string): string;
+/**
+ * Determine the {@link ENTRY_ORDER} for an execution log entry so that entries
+ * are placed in the correct lifecycle sequence. Status entries (deployed,
+ * instance-started, terminal) are always pinned to their lifecycle position
+ * regardless of timestamp. For all other entries the order is used as a
+ * tiebreaker when timestamps are equal.
+ *
+ * Entry order mapping (lower = earlier in the lifecycle):
+ *   ENTRY_ORDER.DEPLOYED                – deployed status
+ *   ENTRY_ORDER.INSTANCE_STARTED        – instance-started status
+ *   ENTRY_ORDER.ELEMENT_ACTIVE          – element-instance ACTIVE
+ *   ENTRY_ORDER.START_LISTENER_CREATED  – start execution listener job CREATED
+ *   ENTRY_ORDER.START_LISTENER_TERMINAL – start execution listener job terminal
+ *   ENTRY_ORDER.WORK_CREATED            – regular job / user-task / message-subscription CREATED
+ *   ENTRY_ORDER.WORK_TERMINAL           – regular job / user-task / message-subscription terminal
+ *   ENTRY_ORDER.END_LISTENER_CREATED    – end execution listener job CREATED
+ *   ENTRY_ORDER.END_LISTENER_TERMINAL   – end execution listener job terminal
+ *   ENTRY_ORDER.ELEMENT_TERMINAL        – element-instance terminal (COMPLETED, TERMINATED, …)
+ *   ENTRY_ORDER.STATUS_TERMINAL         – terminal status entries (completed, incident, …)
+ *
+ * @param {ExecutionLogEntry} entry
+ *
+ * @returns {number}
+ */
+export function getEntryOrder(entry: ExecutionLogEntry): number;
+/**
+ * Check whether two execution log entries are related and should therefore be
+ * ordered by {@link ENTRY_ORDER} when they share a timestamp.
+ *
+ * Runtime entries are considered related when they share an `elementId`
+ * (linking element-instance, job, and message-subscription entries for the
+ * same BPMN element) or, for same-type entries without a common `elementId`,
+ * when they share an identity key (`jobKey`, `userTaskKey`, or
+ * `messageSubscriptionKey`).
+ *
+ * @param {ExecutionLogEntry} a
+ * @param {ExecutionLogEntry} b
+ *
+ * @returns {boolean}
+ */
+export function areRelated(a: ExecutionLogEntry, b: ExecutionLogEntry): boolean;
+/**
+ * Compare two entries by timestamp (ascending).
+ *
+ * @param {ExecutionLogEntry} a
+ * @param {ExecutionLogEntry} b
+ *
+ * @returns {number}
+ */
+export function compareByTimestamp(a: ExecutionLogEntry, b: ExecutionLogEntry): number;
+/**
+ * Check whether two entries have the same timestamp.
+ *
+ * @param {ExecutionLogEntry} a
+ * @param {ExecutionLogEntry} b
+ *
+ * @returns {boolean}
+ */
+export function haveSameTimestamp(a: ExecutionLogEntry, b: ExecutionLogEntry): boolean;
+/**
+ * Compare two entries by their {@link ENTRY_ORDER} lifecycle position (ascending).
+ *
+ * @param {ExecutionLogEntry} a
+ * @param {ExecutionLogEntry} b
+ *
+ * @returns {number}
+ */
+export function compareByOrder(a: ExecutionLogEntry, b: ExecutionLogEntry): number;
+/**
+ * Check whether element `ancestorId` is an ancestor of element `descendantId`
+ * by walking up the parent chain in the element registry.
+ *
+ * @param {Object|null} elementRegistry
+ * @param {string} [ancestorId]
+ * @param {string} [descendantId]
+ *
+ * @returns {boolean}
+ */
+export function isAncestor(elementRegistry: any | null, ancestorId?: string, descendantId?: string): boolean;
+/**
+ * Compare two element-instance entries by containment. When one element is an
+ * ancestor of the other, the ancestor's ACTIVE entry sorts first and its
+ * terminal entry sorts last. Returns 0 when neither entry is an
+ * element-instance or no containment relationship exists.
+ *
+ * @param {Object|null} elementRegistry
+ * @param {ExecutionLogEntry} a
+ * @param {ExecutionLogEntry} b
+ *
+ * @returns {number}
+ */
+export function compareByContainment(elementRegistry: any | null, a: ExecutionLogEntry, b: ExecutionLogEntry): number;
 export namespace EXECUTION_LOG_ENTRY_TYPE {
     let STATUS: "status";
     let JOB: "job";
@@ -87,6 +179,21 @@ export namespace EXECUTION_LOG_ENTRY_STATUS {
     let TERMINATED: "terminated";
     let CANCELED: "canceled";
 }
+export namespace ENTRY_ORDER {
+    let DEPLOYED_1: 0;
+    export { DEPLOYED_1 as DEPLOYED };
+    let INSTANCE_STARTED_1: 1;
+    export { INSTANCE_STARTED_1 as INSTANCE_STARTED };
+    export let ELEMENT_ACTIVE: 2;
+    export let START_LISTENER_CREATED: 3;
+    export let START_LISTENER_TERMINAL: 4;
+    export let WORK_CREATED: 5;
+    export let WORK_TERMINAL: 6;
+    export let END_LISTENER_CREATED: 7;
+    export let END_LISTENER_TERMINAL: 8;
+    export let ELEMENT_TERMINAL: 9;
+    export let STATUS_TERMINAL: 10;
+}
 export default class ExecutionLog {
     /**
      * @param {Injector} [injector]
@@ -188,9 +295,9 @@ import type { ExecutionLogElementInstanceEntry } from './types';
 import type { ExecutionLogMessageSubscriptionEntry } from './types';
 import type { TaskExecutionFinishedResult } from './types';
 import type { ExecutionLogStatusEntry } from './types';
+import type { ExecutionLogEntry } from './types';
 import type { TaskExecutionState } from './types';
 import type { DeployResponse } from './types';
 import type { StartInstanceResponse } from './types';
 import type { TaskExecutionPolledResult } from './types';
-import type { ExecutionLogEntry } from './types';
 import type { Injector } from 'didi';

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

@@ -1,14 +1,10 @@
 /**
  * @param {Object} props
  * @param {ExecutionLogEntry[]} props.entries
- * @param {string} [props.tasklistBaseUrl]
- * @param {string|null} [props.currentOperateUrl]
  * @param {boolean} [props.isTaskExecuting]
  */
-export function ExecutionLog({ entries, tasklistBaseUrl, currentOperateUrl, isTaskExecuting }: {
+export function ExecutionLog({ entries, isTaskExecuting }: {
     entries: ExecutionLogEntry[];
-    tasklistBaseUrl?: string | undefined;
-    currentOperateUrl?: string | null | undefined;
     isTaskExecuting?: boolean | undefined;
 }): import("react/jsx-runtime").JSX.Element;
 export namespace JOB_STATES {

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

@@ -23,6 +23,22 @@ export default function Output({ element, isConnectionConfigured, isTaskExecutin
     tasklistBaseUrl?: string | undefined;
     currentVariables?: any;
 }): import("react/jsx-runtime").JSX.Element;
+/**
+ * Get the waiting context describing what the execution is currently blocked on.
+ * Returns null if nothing is being waited on.
+ *
+ * @param {ExecutionLogEntry[]} [entries]
+ * @param {string} [tasklistBaseUrl]
+ * @param {string|null} [currentOperateUrl]
+ *
+ * @returns {{ title: string, description: React.ReactNode, linkUrl: string|null, linkLabel: string } | null}
+ */
+export function getWaitingContext(entries?: ExecutionLogEntry[], tasklistBaseUrl?: string, currentOperateUrl?: string | null): {
+    title: string;
+    description: React.ReactNode;
+    linkUrl: string | null;
+    linkLabel: string;
+} | null;
 export function HeaderLink({ children, render, visible, href, target, className, onClick, renderIcon, role, tooltip, priority }: {
     children?: null | undefined;
     render?: ((props?: any) => React.ReactNode) | undefined;

package/dist/types/types.d.ts

@@ -72,9 +72,9 @@ export type TaskExecutionApi = {
     getProcessInstance: (processInstanceKey: string) => Promise<GetProcessInstanceResponse>;
     getProcessInstanceElementInstances: (processInstanceKey: string) => Promise<GetProcessInstanceElementInstancesResponse>;
     getProcessInstanceIncident: (processInstanceKey: string) => Promise<GetProcessInstanceIncidentsResponse>;
-    getProcessInstanceJobs: (processInstanceKey: string, elementId: string) => Promise<GetProcessInstanceJobsResponse>;
-    getProcessInstanceMessageSubscriptions: (processInstanceKey: string, elementId: string) => Promise<GetProcessInstanceMessageSubscriptionsResponse>;
-    getProcessInstanceUserTasks: (processInstanceKey: string, elementId: string) => Promise<GetProcessInstanceUserTasksResponse>;
+    getProcessInstanceJobs: (processInstanceKey: string) => Promise<GetProcessInstanceJobsResponse>;
+    getProcessInstanceMessageSubscriptions: (processInstanceKey: string) => Promise<GetProcessInstanceMessageSubscriptionsResponse>;
+    getProcessInstanceUserTasks: (processInstanceKey: string) => Promise<GetProcessInstanceUserTasksResponse>;
     getProcessInstanceVariables: (processInstanceKey: string) => Promise<GetProcessInstanceVariablesResponse>;
     startInstance: (processDefinitionKey: string, elementId: string, variables: {
         [key: string]: any;
@@ -174,6 +174,7 @@ export type ExecutionLogJobData = {
 export type ExecutionLogUserTaskData = {
     state: string;
     name?: string;
+    elementId?: string;
     userTaskKey?: string;
     creationDate?: string;
     completionDate?: string;

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

@@ -0,0 +1,18 @@
+/**
+ * Compute a default input config from the element's input requirements, producing a JSON string with `null` stubs for each required variable.
+ *
+ * @param {Object} elementVariables
+ * @param {Object} element
+ * @returns {Promise<string>} JSON string
+ */
+export function computeDefaultInput(elementVariables: any, element: any): Promise<string>;
+/**
+ * Merge current input with fresh input requirements from the element. User edits have higher priority.
+ *
+ * @param {string} currentInputString - stored JSON string (or undefined)
+ * @param {Object} elementVariables
+ * @param {Object} element
+ * @returns {Promise<string|null>} merged JSON string, or null if unparseable
+ */
+export function computeMergedInput(currentInputString: string, elementVariables: any, element: any): Promise<string | null>;
+export const DEFAULT_INPUT_CONFIG: "{\n  \n}";

package/package.json

@@ -1,101 +1,101 @@
-{
-  "name": "@camunda/task-testing",
-  "version": "3.0.0",
-  "files": [
-    "dist"
-  ],
-  "main": "dist/index.js",
-  "types": "dist/types/index.d.ts",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/camunda/task-testing"
-  },
-  "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": "^5.0.0"
-  },
-  "devDependencies": {
-    "@babel/core": "^7.28.0",
-    "@babel/preset-env": "^7.28.0",
-    "@babel/preset-react": "^7.27.1",
-    "@bpmn-io/variable-resolver": "^2.0.0",
-    "@camunda8/orchestration-cluster-api": "^8.8.4",
-    "@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.1.1",
-    "bpmn-js-element-templates": "^2.22.0",
-    "bpmn-js-headless": "^0.1.0",
-    "bpmn-js-properties-panel": "^5.53.0",
-    "camunda-bpmn-js": "^5.24.2",
-    "chai": "^4.5.0",
-    "css-loader": "^7.1.4",
-    "dotenv": "^17.2.1",
-    "eslint": "^9.31.0",
-    "eslint-plugin-bpmn-io": "^2.2.0",
-    "express": "^5.1.0",
-    "html-webpack-plugin": "^5.6.6",
-    "karma": "^6.4.4",
-    "karma-chrome-launcher-2": "^3.3.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",
-    "puppeteer": "^24.38.0",
-    "raw-loader": "^4.0.2",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
-    "sass": "^1.97.3",
-    "sass-loader": "^16.0.7",
-    "sinon": "^17.0.1",
-    "sinon-chai": "^3.7.0",
-    "style-loader": "^4.0.0",
-    "typescript": "^5.9.2",
-    "webpack": "^5.105.4",
-    "webpack-cli": "^6.0.1",
-    "webpack-dev-server": "^5.2.3",
-    "zeebe-bpmn-moddle": "^1.11.0"
-  },
-  "peerDependencies": {
-    "camunda-bpmn-js": "*",
-    "react": "*",
-    "react-dom": "*"
-  },
-  "overrides": {
-    "react-is": "^18.0.0"
-  }
-}
+{
+  "name": "@camunda/task-testing",
+  "version": "4.0.0",
+  "files": [
+    "dist"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/types/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/camunda/task-testing"
+  },
+  "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": "^5.0.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.28.0",
+    "@babel/preset-env": "^7.28.0",
+    "@babel/preset-react": "^7.27.1",
+    "@bpmn-io/variable-resolver": "^3.0.0",
+    "@camunda8/orchestration-cluster-api": "^8.8.4",
+    "@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.1.1",
+    "bpmn-js-element-templates": "^2.22.0",
+    "bpmn-js-headless": "^0.1.0",
+    "bpmn-js-properties-panel": "^5.53.0",
+    "camunda-bpmn-js": "^5.25.0",
+    "chai": "^4.5.0",
+    "css-loader": "^7.1.4",
+    "dotenv": "^17.2.1",
+    "eslint": "^9.31.0",
+    "eslint-plugin-bpmn-io": "^2.2.0",
+    "express": "^5.1.0",
+    "html-webpack-plugin": "^5.6.6",
+    "karma": "^6.4.4",
+    "karma-chrome-launcher-2": "^3.3.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",
+    "puppeteer": "^24.38.0",
+    "raw-loader": "^4.0.2",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "sass": "^1.97.3",
+    "sass-loader": "^16.0.7",
+    "sinon": "^17.0.1",
+    "sinon-chai": "^3.7.0",
+    "style-loader": "^4.0.0",
+    "typescript": "^5.9.2",
+    "webpack": "^5.105.4",
+    "webpack-cli": "^6.0.1",
+    "webpack-dev-server": "^5.2.3",
+    "zeebe-bpmn-moddle": "^1.11.0"
+  },
+  "peerDependencies": {
+    "camunda-bpmn-js": "*",
+    "react": "*",
+    "react-dom": "*"
+  },
+  "overrides": {
+    "react-is": "^18.0.0"
+  }
+}