@onify/flow-extensions/dist/index.js

Onify Flow extensions

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
Object.defineProperty(exports, "OnifySequenceFlow", {
  enumerable: true,
  get: function () {
    return _OnifySequenceFlow.OnifySequenceFlow;
  }
});
Object.defineProperty(exports, "OnifyTimerEventDefinition", {
  enumerable: true,
  get: function () {
    return _OnifyTimerEventDefinition.OnifyTimerEventDefinition;
  }
});
exports.extendFn = extendFn;
exports.extensions = extensions;
var _OnifyProcessExtensions = require("./OnifyProcessExtensions.js");
var _OnifyElementExtensions = require("./OnifyElementExtensions.js");
var _OnifyBoundaryEventExtensions = require("./OnifyBoundaryEventExtensions.js");
var _OnifySubProcessExtensions = require("./OnifySubProcessExtensions.js");
var _OnifySequenceFlow = require("./OnifySequenceFlow.js");
var _OnifyTimerEventDefinition = require("./OnifyTimerEventDefinition.js");
function extensions(element, context) {
  switch (element.type) {
    case 'bpmn:Process':
      return new _OnifyProcessExtensions.OnifyProcessExtensions(element, context);
    case 'bpmn:AdHocSubProcess':
    case 'bpmn:SubProcess':
    case 'bpmn:Transaction':
      return new _OnifySubProcessExtensions.OnifySubProcessExtensions(element, context);
    case 'bpmn:BoundaryEvent':
      return new _OnifyBoundaryEventExtensions.OnifyBoundaryEventExtensions(element, context);
    default:
      return new _OnifyElementExtensions.OnifyElementExtensions(element, context);
  }
}
function extendFn(behaviour, context) {
  switch (behaviour.$type) {
    case 'bpmn:StartEvent':
      {
        if (!behaviour.eventDefinitions) break;
        const timer = behaviour.eventDefinitions.find(({
          type,
          behaviour: edBehaviour
        }) => edBehaviour && type === 'bpmn:TimerEventDefinition');
        if (timer && timer.behaviour.timeCycle) Object.assign(behaviour, {
          scheduledStart: timer.behaviour.timeCycle
        });
        break;
      }
    case 'bpmn:Process':
      {
        if (!behaviour.isExecutable) break;
        const {
          historyTimeToLive,
          isExecutable
        } = behaviour;
        if (historyTimeToLive && isExecutable) {
          context.addTimer(behaviour.id + ':historyTimeToLive', getHistoryTimeToLiveTimer(behaviour));
        }
        break;
      }
  }
  if (!Array.isArray(behaviour.extensionElements?.values)) return;
  let listener = 0;
  for (const extension of behaviour.extensionElements.values) {
    switch (extension.$type) {
      case 'camunda:InputOutput':
        registerIOScripts(behaviour.id, context, extension.$type, extension);
        break;
      case 'camunda:Connector':
        registerIOScripts(behaviour.id, context, extension.$type, extension.inputOutput);
        break;
      case 'camunda:ExecutionListener':
        registerListenerScript(behaviour.id, context, extension.$type, extension, listener++);
        break;
    }
  }
}
function registerIOScripts(parentId, context, type, ioBehaviour) {
  if (!ioBehaviour) return;
  const {
    inputParameters = [],
    outputParameters = []
  } = ioBehaviour;
  for (const {
    $type,
    name,
    definition
  } of inputParameters.concat(outputParameters)) {
    if (!definition) continue;
    if (definition.$type !== 'camunda:Script') continue;
    const ioType = `${type}/${$type}`;
    const filename = `${parentId}/${ioType}/${name}`;
    context.addScript(filename, {
      id: filename,
      scriptFormat: definition.scriptFormat,
      type: ioType,
      ...(definition.value && {
        body: definition.value
      }),
      ...(definition.resource && {
        resource: definition.resource
      })
    });
  }
}
function registerListenerScript(parentId, context, type, listener, pos) {
  const {
    event,
    script
  } = listener;
  if (!script) return;
  const id = `${parentId}/${type}/${event}/${pos}`;
  context.addScript(id, {
    id,
    scriptFormat: script.scriptFormat,
    type,
    ...(script.value && {
      body: script.value
    }),
    ...(script.resource && {
      resource: script.resource
    })
  });
}
function getHistoryTimeToLiveTimer(behaviour) {
  const {
    id,
    $type: type,
    historyTimeToLive
  } = behaviour;
  let value = historyTimeToLive;
  let days;
  if (!isNaN(days = Number(value))) {
    value = `P${days > 0 ? days : 0}D`;
  }
  return {
    id: `${type}/${id}:historyTimeToLive`,
    type: 'historyTimeToLive',
    timerType: 'timeDuration',
    value,
    parent: {
      id,
      type
    }
  };
}