@0dep/bpmn-extensions 0.0.1

package/dist/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "@0dep/bpmn-extensions",
+  "version": "0.0.1",
+  "description": "Flow extensions for bpmn-elements: FEEL expressions and the zeebe-namespace BPMN extension elements",
+  "type": "module",
+  "module": "src/index.js",
+  "main": "dist/index.js",
+  "types": "./types/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./src/index.js"
+    }
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "test": "mocha",
+    "test:lcov": "c8 -r lcov mocha && npm run lint",
+    "test:md": "texample",
+    "cov:html": "c8 mocha && c8 report --reporter html",
+    "posttest": "npm run lint && npm run test:md && npm run prepack",
+    "lint": "eslint . --cache && prettier . --check --cache",
+    "format": "eslint . --fix && prettier . --write",
+    "dist": "rollup -c",
+    "types": "dts-buddy types/index.d.ts -m @0dep/bpmn-extensions:src/index.js",
+    "prepack": "npm run dist && npm run types"
+  },
+  "keywords": [
+    "bpmn",
+    "bpmn-elements",
+    "camunda",
+    "camunda8",
+    "zeebe",
+    "feel",
+    "extensions"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zerodep/bpmn-extensions.git"
+  },
+  "author": {
+    "name": "Pål Edman",
+    "url": "https://github.com/paed01"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "bpmn-elements": ">=18.0.4"
+  },
+  "dependencies": {
+    "feelin": "^7.0.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@rollup/plugin-commonjs": "^29.0.3",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "bpmn-elements": "^18.0.4",
+    "bpmn-moddle": "^9.0.1",
+    "c8": "^11.0.0",
+    "chai": "^6.2.2",
+    "debug": "^4.4.3",
+    "dts-buddy": "^0.8.2",
+    "eslint": "^10.6.0",
+    "globals": "^17.7.0",
+    "mocha": "^11.7.6",
+    "mocha-cakes-2": "^3.3.0",
+    "moddle-context-serializer": "^6.0.1",
+    "prettier": "^3.9.1",
+    "rollup": "^4.62.2",
+    "texample": "^1.0.2",
+    "typescript": "^6.0.3",
+    "zeebe-bpmn-moddle": "^1.15.0"
+  },
+  "files": [
+    "src",
+    "dist",
+    "types"
+  ],
+  "c8": {
+    "exclude": [
+      "dist",
+      "test"
+    ]
+  }
+}

package/src/ElementExtensions.js

@@ -0,0 +1,142 @@
+import { getExtensions } from './getExtensions.js';
+
+const SUBPROCESS_TYPES = new Set(['bpmn:SubProcess', 'bpmn:AdHocSubProcess', 'bpmn:Transaction']);
+
+/**
+ * Activity-level extensions.
+ *
+ * Formatting and io/listener side effects are injected through the activity's `format-run-q`
+ * queue so the activity waits for them (including async execution listeners) before
+ * proceeding — the same mechanism bpmn-elements uses for extension formatting.
+ */
+export class ElementExtensions {
+  constructor(activity) {
+    this.activity = activity;
+    this.formatQ = activity.broker.getQueue('format-run-q');
+
+    this.extensions = getExtensions(activity);
+    const Service = this.extensions.Service;
+    if (Service) activity.behaviour.Service = Service;
+  }
+  activate(message) {
+    const activity = this.activity;
+    const listeners = this.extensions.listeners;
+
+    if (message.fields.redelivered && message.fields.routingKey === 'run.start') {
+      activity.on('start', (api) => this._onEnter(api), { consumerTag: '0dep-bpmn-extensions:on-enter' });
+    } else {
+      activity.on('enter', (api) => this._onEnter(api), { consumerTag: '0dep-bpmn-extensions:on-enter' });
+    }
+
+    activity.on('activity.execution.completed', (api) => this._onExecuted(api), {
+      consumerTag: '0dep-bpmn-extensions:on-executed',
+    });
+
+    if (listeners?.onStart) {
+      activity.on('start', (api) => this._onListener('start', api), { consumerTag: '0dep-bpmn-extensions:on-start' });
+    }
+    if (listeners?.onEnd) {
+      activity.on('end', (api) => this._onListener('end', api), { consumerTag: '0dep-bpmn-extensions:on-end' });
+    }
+  }
+  deactivate() {
+    const broker = this.activity.broker;
+    broker.cancel('0dep-bpmn-extensions:on-enter');
+    broker.cancel('0dep-bpmn-extensions:on-executed');
+    broker.cancel('0dep-bpmn-extensions:on-start');
+    broker.cancel('0dep-bpmn-extensions:on-end');
+  }
+  /** @internal Shared with SubProcessExtensions. */
+  async _onEnter(elementApi) {
+    this.formatQ.queueMessage({ routingKey: 'run.enter.format' }, { endRoutingKey: 'run.enter.complete' }, { persistent: false });
+    try {
+      const format = await this.#formatOnEnter(elementApi);
+      elementApi.broker.publish('format', 'run.enter.complete', format, { persistent: false });
+    } catch (err) {
+      elementApi.broker.publish('format', 'run.enter.error', { error: err }, { persistent: false });
+    }
+  }
+  /** @internal Shared with SubProcessExtensions. */
+  async _onExecuted(elementApi) {
+    this.formatQ.queueMessage({ routingKey: 'run.end.format' }, { endRoutingKey: 'run.end.complete' }, { persistent: false });
+    try {
+      const format = await this.#formatOnExecuted(elementApi);
+      elementApi.broker.publish('format', 'run.end.complete', { ...format }, { persistent: false });
+    } catch (err) {
+      elementApi.broker.publish('format', 'run.end.error', { error: err }, { persistent: false });
+    }
+  }
+  /** @internal Shared with SubProcessExtensions. */
+  async _onListener(eventType, elementApi) {
+    const routingKey = `run.listener.${eventType}`;
+    this.formatQ.queueMessage({ routingKey }, { endRoutingKey: `${routingKey}.complete` }, { persistent: false });
+    try {
+      await this.extensions.listeners.execute(eventType, elementApi);
+      elementApi.broker.publish('format', `${routingKey}.complete`, {}, { persistent: false });
+    } catch (err) {
+      this.activity.logger.error(`<${this.activity.id}> ${eventType} execution listener error`, err);
+      elementApi.broker.publish('format', `${routingKey}.error`, { error: err }, { persistent: false });
+    }
+  }
+  #formatOnEnter(elementApi) {
+    const { format, io, headers, properties, form } = this.extensions;
+    const result = { ...format.resolve(elementApi) };
+
+    if (headers) result.headers = headers.resolve();
+    if (properties) result.properties = properties.resolve(elementApi);
+    if (form) result.form = form.resolve(elementApi);
+    if (io?.hasInput) {
+      result.input = io.getInput(elementApi);
+      // A (sub) process input mapping creates local variables visible to its children; a job
+      // (service task) or call activity keeps the input on the content (passed to the worker /
+      // propagated to the called process) instead of polluting the variables.
+      if (SUBPROCESS_TYPES.has(this.activity.type)) this.activity.environment.assignVariables(result.input);
+    }
+
+    Object.assign(elementApi.content, result);
+    return result;
+  }
+  #formatOnExecuted(elementApi) {
+    const { io, script, loop } = this.extensions;
+    let jobResult = elementApi.content.output;
+
+    // Multi-instance: aggregate the per-instance outputs into the `outputCollection` array.
+    if (loop?.hasOutputCollection) {
+      const output = { [loop.outputCollection]: loop.aggregate(jobResult, elementApi.environment.variables) };
+      this.#assignOutput(elementApi, output);
+      return { output };
+    }
+
+    // A call activity wraps the called process output as `{ executionId, output }`. Unwrap it so
+    // output mapping / the variable merge operates on the called process's variables.
+    if (this.activity.type === 'bpmn:CallActivity' && jobResult?.executionId && jobResult.output) {
+      jobResult = jobResult.output;
+    }
+
+    // A script task's FEEL result is named by its `resultVariable`; a job's result is already
+    // an object of variables.
+    const resultObject = script ? (script.resultVariable ? { [script.resultVariable]: jobResult } : undefined) : jobResult;
+
+    let output;
+    if (io?.hasOutput) {
+      output = io.getOutput(elementApi, resultObject);
+    } else if (resultObject !== null && typeof resultObject === 'object') {
+      // No output mapping: merge the whole result into the process variables.
+      output = resultObject;
+    }
+
+    if (output) {
+      this.#assignOutput(elementApi, output);
+      return { output };
+    }
+    return {};
+  }
+  #assignOutput(elementApi, output) {
+    const environment = this.activity.environment;
+    // Visible to downstream FEEL within the process, and surfaced as process output
+    // (bpmn-elements bubbles process `environment.output` up to the definition on completion).
+    environment.assignVariables(output);
+    Object.assign(environment.output, output);
+    Object.assign(elementApi.content, { output });
+  }
+}

package/src/Errors.js

@@ -0,0 +1,15 @@
+export class ServiceError extends Error {
+  constructor(jobType) {
+    super(`service for job type <${jobType}> is not implemented`);
+    this.code = 'EBPMN_SERVICE_NOT_IMPLEMENTED';
+    this.output = { statusCode: 501 };
+  }
+}
+
+export class FormatError extends Error {
+  constructor(elementId, err) {
+    super(`<${elementId}> ${err.message}`);
+    this.code = 'EBPMN_FORMAT';
+    this.output = { statusCode: 500 };
+  }
+}

package/src/Expressions.js

@@ -0,0 +1,49 @@
+import { isFeelExpression, evaluateFeel } from './feel.js';
+
+/**
+ * FEEL-aware expressions implementation for bpmn-elements.
+ *
+ * Plug it into the engine via the environment `expressions` option so that the whole
+ * definition resolves FEEL expressions (`= ...`) instead of the default
+ * `${...}` template expressions.
+ *
+ * @returns {import('bpmn-elements').IExpressions}
+ */
+export function FeelExpressions() {
+  return {
+    resolveExpression,
+    isExpression,
+    hasExpression,
+  };
+}
+
+function isExpression(text) {
+  return isFeelExpression(text);
+}
+
+function hasExpression(text) {
+  return isFeelExpression(text);
+}
+
+/**
+ * Resolve a templated string. Static literals are returned as-is; FEEL expressions are
+ * evaluated against the environment variables (overlaid with any element-local variables).
+ * @param {string} templatedString
+ * @param {{ environment?: import('bpmn-elements').Environment, content?: any }} [context]
+ */
+function resolveExpression(templatedString, context) {
+  if (!isFeelExpression(templatedString)) return templatedString;
+  return evaluateFeel(templatedString, getScope(context));
+}
+
+/**
+ * Build the FEEL variable scope from a resolution context. Process/definition variables form
+ * the base scope, overlaid with any local variables carried on the element message content
+ * (e.g. a multi-instance item).
+ */
+function getScope(context) {
+  const environment = context && context.environment;
+  const variables = environment ? environment.variables : {};
+  const local = context && context.content && context.content.variables;
+  return { ...variables, ...local };
+}

package/src/ProcessExtensions.js

@@ -0,0 +1,49 @@
+import { FormatError } from './Errors.js';
+import { getExtensions } from './getExtensions.js';
+
+/**
+ * Process-level extensions. Formats the process on enter (documentation) and assigns
+ * the result to the process variables.
+ */
+export class ProcessExtensions {
+  constructor(bp) {
+    this.process = bp;
+    this.extensions = getExtensions(bp);
+  }
+  activate() {
+    // bpmn-elements (>=18.0.3) calls activate() on `run.enter`, before `process.enter` is published.
+    const bp = this.process;
+    bp.broker.subscribeTmp('event', 'process.enter', (_, message) => this.#onEnter(bp.getApi(message)), {
+      noAck: true,
+      consumerTag: '0dep-bpmn-extensions:on-enter',
+    });
+  }
+  deactivate() {
+    this.process.broker.cancel('0dep-bpmn-extensions:on-enter');
+  }
+  #onEnter(elementApi) {
+    try {
+      // bpmn-elements (>=18.0.4) forwards a call activity's formatted input — its io mapping plus,
+      // for a multi-instance, the loop element variable — on the called process's inbound content.
+      // Promote it to top-level process variables (addressable by name; bpmn-elements itself only
+      // exposes it nested under `input`).
+      const inbound = elementApi.content.inbound;
+      if (Array.isArray(inbound)) {
+        for (const from of inbound) {
+          if (from?.input && typeof from.input === 'object') elementApi.environment.assignVariables(from.input);
+        }
+      }
+
+      const result = this.extensions.format.resolve(elementApi);
+      Object.assign(elementApi.content, result);
+      elementApi.environment.assignVariables(result);
+    } catch (err) {
+      elementApi.broker.publish(
+        'event',
+        'process.error',
+        { ...elementApi.content, error: new FormatError(this.process.id, err) },
+        { mandatory: true, type: 'error' }
+      );
+    }
+  }
+}

package/src/SubProcessExtensions.js

@@ -0,0 +1,39 @@
+import { ElementExtensions } from './ElementExtensions.js';
+
+/**
+ * Sub-process extensions.
+ *
+ * A sub-process shares its broker with the child activities it contains, so their
+ * `activity.*` events bubble through it. Subscribing with `activity.on(...)` (as a leaf
+ * element does) would therefore fire the extension handlers for every child and spam the
+ * sub-process format queue, stalling it. Instead, subscribe on the broker and filter to the
+ * sub-process's own id.
+ */
+export class SubProcessExtensions extends ElementExtensions {
+  activate(message) {
+    const listeners = this.extensions.listeners;
+    const enterKey = message.fields.redelivered && message.fields.routingKey === 'run.start' ? 'activity.start' : 'activity.enter';
+
+    this.#subscribe(enterKey, (api) => this._onEnter(api), '0dep-bpmn-extensions:on-enter');
+    this.#subscribe('activity.execution.completed', (api) => this._onExecuted(api), '0dep-bpmn-extensions:on-executed');
+
+    if (listeners?.onStart) {
+      this.#subscribe('activity.start', (api) => this._onListener('start', api), '0dep-bpmn-extensions:on-start');
+    }
+    if (listeners?.onEnd) {
+      this.#subscribe('activity.end', (api) => this._onListener('end', api), '0dep-bpmn-extensions:on-end');
+    }
+  }
+  #subscribe(routingKey, callback, consumerTag) {
+    const activity = this.activity;
+    activity.broker.subscribeTmp(
+      'event',
+      routingKey,
+      (_, message) => {
+        if (activity.id !== message.content.id) return;
+        return callback(activity.getApi(message));
+      },
+      { noAck: true, consumerTag }
+    );
+  }
+}

package/src/extensions/ExecutionListeners.js

@@ -0,0 +1,58 @@
+import { ServiceError } from '../Errors.js';
+
+/**
+ * `zeebe:executionListeners`.
+ *
+ * Each listener invokes a job worker (an environment service named by the listener `type`)
+ * either before the element runs (`eventType: "start"`) or after it completes
+ * (`eventType: "end"`). A listener is called as `(elementApi, { retries, headers }, callback)` and
+ * may either call the callback or return a promise — either way the element blocks until it
+ * settles. `retries` and `headers` are only present when the listener declares them (no defaults
+ * are invented).
+ */
+export class ExecutionListeners {
+  constructor(activity, executionListeners) {
+    this.activity = activity;
+    this.listeners = executionListeners.listeners || [];
+  }
+  get onStart() {
+    return this.listeners.some((l) => l.eventType === 'start');
+  }
+  get onEnd() {
+    return this.listeners.some((l) => l.eventType === 'end');
+  }
+  /**
+   * Execute all listeners registered for an event type, in order.
+   * @param {'start'|'end'} eventType
+   * @param {import('bpmn-elements').IApi<any>} elementApi
+   */
+  async execute(eventType, elementApi) {
+    const environment = this.activity.environment;
+    for (const listener of this.listeners) {
+      if (listener.eventType !== eventType) continue;
+      const serviceFn = environment.services[listener.type];
+      if (typeof serviceFn !== 'function') throw new ServiceError(listener.type);
+
+      const options = {};
+      if (listener.retries !== undefined) {
+        const retries = Number(listener.retries);
+        options.retries = Number.isFinite(retries) ? retries : listener.retries;
+      }
+
+      const headerValues = listener.headers?.values;
+      if (headerValues?.length) {
+        const headers = {};
+        for (const { key, value } of headerValues) {
+          if (key !== undefined) headers[key] = value;
+        }
+        options.headers = headers;
+      }
+
+      // A listener may either call the callback or return a promise; await whichever settles.
+      await new Promise((resolve, reject) => {
+        const returned = serviceFn.call(this.activity, elementApi, options, (err, result) => (err ? reject(err) : resolve(result)));
+        if (returned && typeof returned.then === 'function') returned.then(resolve, reject);
+      });
+    }
+  }
+}

package/src/extensions/FeelScripts.js

@@ -0,0 +1,49 @@
+import { isFeelExpression, evaluateFeel } from '../feel.js';
+
+/**
+ * A bpmn-elements `scripts` implementation for script tasks.
+ *
+ * A script task carries a `zeebe:script` extension with a FEEL `expression` (and a
+ * `resultVariable`). There is no embedded script body and no `scriptFormat` attribute, so this
+ * registry ignores the script format and reads the expression straight off the element.
+ *
+ * Install it on the environment via the `scripts` option, alongside `FeelExpressions()`.
+ *
+ * @returns {import('bpmn-elements').IScripts}
+ */
+export function FeelScripts() {
+  return new FeelScriptRegistry();
+}
+
+class FeelScriptRegistry {
+  register() {}
+  getScript(_scriptFormat, activity) {
+    const expression = getScriptExpression(activity);
+    if (expression === undefined) return undefined;
+    return new FeelScript(expression);
+  }
+}
+
+class FeelScript {
+  constructor(expression) {
+    this.expression = expression;
+  }
+  execute(scope, callback) {
+    try {
+      const value = isFeelExpression(this.expression) ? evaluateFeel(this.expression, { ...scope.environment.variables }) : this.expression;
+      callback(null, value);
+    } catch (err) {
+      callback(err);
+    }
+  }
+}
+
+/**
+ * Read the `zeebe:script` FEEL expression from a script task's extension elements.
+ */
+function getScriptExpression(activity) {
+  const values = activity.behaviour?.extensionElements?.values;
+  if (!values) return undefined;
+  const script = values.find((v) => v.$type === 'zeebe:Script');
+  return script?.expression;
+}

package/src/extensions/Form.js

@@ -0,0 +1,26 @@
+import { resolveValue } from '../feel.js';
+
+/**
+ * `zeebe:formDefinition`.
+ *
+ * User tasks (and form-bearing start events) reference their form here: a linked
+ * form (`formId`), a deprecated form key (`formKey`), or an external form
+ * (`externalReference`, which may be a FEEL expression). Resolved to a plain object and made
+ * available on the element content as `form` so a task list can render it.
+ */
+export class Form {
+  constructor(formDefinition) {
+    this.formDefinition = formDefinition;
+  }
+  resolve(elementApi) {
+    const scope = elementApi.environment.variables;
+    const { formId, formKey, externalReference, bindingType, versionTag } = this.formDefinition;
+    return {
+      ...(formId !== undefined && { formId: resolveValue(formId, scope) }),
+      ...(formKey !== undefined && { formKey: resolveValue(formKey, scope) }),
+      ...(externalReference !== undefined && { externalReference: resolveValue(externalReference, scope) }),
+      ...(bindingType !== undefined && { bindingType }),
+      ...(versionTag !== undefined && { versionTag }),
+    };
+  }
+}

package/src/extensions/IoMapping.js

@@ -0,0 +1,68 @@
+import { resolveValue } from '../feel.js';
+
+/**
+ * `zeebe:ioMapping`.
+ *
+ * Input parameters are evaluated in the parent (process) scope when the element is entered,
+ * producing the local variables the job runs with. Output parameters are evaluated in the
+ * job-result scope when the element completes, merging the result back into the process
+ * variables.
+ *
+ * Each parameter has a `source` (a FEEL expression or static value) and a `target`
+ * (a, possibly dotted, variable name).
+ */
+export class IoMapping {
+  constructor(activity, ioMapping) {
+    this.activity = activity;
+    this.inputParameters = ioMapping.inputParameters || [];
+    this.outputParameters = ioMapping.outputParameters || [];
+  }
+  get hasInput() {
+    return this.inputParameters.length > 0;
+  }
+  get hasOutput() {
+    return this.outputParameters.length > 0;
+  }
+  /**
+   * Resolve input parameters against the current process variables.
+   * @param {import('bpmn-elements').IApi<any>} elementApi
+   */
+  getInput(elementApi) {
+    const scope = elementApi.environment.variables;
+    const result = {};
+    for (const { source, target } of this.inputParameters) {
+      if (!target) continue;
+      setPath(result, target, resolveValue(source, scope));
+    }
+    return result;
+  }
+  /**
+   * Resolve output parameters against the job result overlaid on the process variables.
+   * @param {import('bpmn-elements').IApi<any>} elementApi
+   * @param {Record<string, any>} [jobResult] Variables produced by the job
+   */
+  getOutput(elementApi, jobResult) {
+    const scope = { ...elementApi.environment.variables, ...jobResult };
+    const result = {};
+    for (const { source, target } of this.outputParameters) {
+      if (!target) continue;
+      setPath(result, target, resolveValue(source, scope));
+    }
+    return result;
+  }
+}
+
+/**
+ * Assign a value to a (possibly dotted) `target` path, creating intermediate objects as needed —
+ * mirrors how an output `target` such as `order.id` maps to a nested object.
+ */
+function setPath(target, path, value) {
+  const keys = String(path).split('.');
+  let cursor = target;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (typeof cursor[key] !== 'object' || cursor[key] === null) cursor[key] = {};
+    cursor = cursor[key];
+  }
+  cursor[keys[keys.length - 1]] = value;
+}

package/src/extensions/LoopCharacteristics.js

@@ -0,0 +1,44 @@
+import { resolveValue } from '../feel.js';
+
+/**
+ * Output side of `zeebe:loopCharacteristics`.
+ *
+ * A multi-instance is aggregated into an `outputCollection` array: for each instance the
+ * `outputElement` FEEL expression is evaluated in that instance's result scope and collected, in
+ * input order, into the named collection variable.
+ *
+ * bpmn-elements collects instance outputs into an index-keyed object on the activity content
+ * (`{ 0: <out>, 1: <out>, ... }`, where a call activity instance wraps its result as
+ * `{ executionId, output }`). This reduces that to the output-collection array.
+ */
+export class LoopCharacteristics {
+  constructor(loopCharacteristics) {
+    this.outputCollection = loopCharacteristics.outputCollection;
+    this.outputElement = loopCharacteristics.outputElement;
+  }
+  get hasOutputCollection() {
+    return Boolean(this.outputCollection);
+  }
+  /**
+   * @param {Record<string, any>|undefined} indexedOutput bpmn-elements index-keyed instance outputs
+   * @param {Record<string, any>} baseScope process variables in scope for `outputElement`
+   * @returns {any[]}
+   */
+  aggregate(indexedOutput, baseScope) {
+    const result = [];
+    if (!indexedOutput || typeof indexedOutput !== 'object') return result;
+
+    const indexes = Object.keys(indexedOutput)
+      .filter((key) => /^\d+$/.test(key))
+      .sort((a, b) => Number(a) - Number(b));
+
+    for (const index of indexes) {
+      const instance = indexedOutput[index];
+      // A call activity instance wraps its result as { executionId, output }.
+      const instanceOutput = instance?.executionId && instance.output ? instance.output : instance;
+      const scope = { ...baseScope, ...instanceOutput };
+      result.push(this.outputElement ? resolveValue(this.outputElement, scope) : instanceOutput);
+    }
+    return result;
+  }
+}

package/src/extensions/Properties.js

@@ -0,0 +1,22 @@
+import { resolveValue } from '../feel.js';
+
+/**
+ * `zeebe:properties`.
+ *
+ * Named properties whose values may be FEEL expressions. Resolved to a plain object and made
+ * available on the element content as `properties`.
+ */
+export class Properties {
+  constructor(properties) {
+    this.properties = properties.properties || [];
+  }
+  resolve(elementApi) {
+    const scope = elementApi.environment.variables;
+    const result = {};
+    for (const { name, value } of this.properties) {
+      if (name === undefined) continue;
+      result[name] = resolveValue(value, scope);
+    }
+    return result;
+  }
+}