onGetComponent(type, priority, callback) {
if (isFunction(priority)) {
callback = priority;
priority = DEFAULT_PRIORITY;
}
if (!isNumber(priority)) {
throw new Error('priority must be a number');
}
const listeners = this._getListeners(type);
let existingListener,
idx;
const newListener = { priority, callback };
for (idx = 0; (existingListener = listeners[idx]); idx++) {
if (existingListener.priority < priority) {
// prepend newListener at before existingListener
listeners.splice(idx, 0, newListener);
return;
}
}
listeners.push(newListener);
}
ContextPad.prototype.trigger = function(action, event, autoActivate) {
var element = this._current.element,
entries = this._current.entries,
entry,
handler,
originalEvent,
button = event.delegateTarget || event.target;
if (!button) {
return event.preventDefault();
}
entry = entries[domAttr(button, 'data-action')];
handler = entry.action;
originalEvent = event.originalEvent || event;
// simple action (via callback function)
if (isFunction(handler)) {
if (action === 'click') {
return handler(originalEvent, element, autoActivate);
}
} else {
if (handler[action]) {
return handler[action](originalEvent, element, autoActivate);
}
}
// silence other actions
event.preventDefault();
};
function write(element, options, callback) {
if (isFunction(options)) {
callback = options;
options = {};
}
// skip preamble for tests
options = assign({ preamble: false }, options);
moddle.toXML(element, options, callback);
}
function createViewer(xml, diagramId, done) {
if (isFunction(diagramId)) {
done = diagramId;
diagramId = null;
}
var viewer = new Viewer({ container: container });
viewer.importXML(xml, diagramId, function(err, warnings) {
done(err, warnings, viewer);
});
}
Cli.prototype._registerParser = function(name, Parser) {
var parser = this._injector.invoke(Parser);
// must return a function(val, options) -> result
if (!isFunction(parser)) {
throw new Error(
'parser must be a Function<String, Object> -> Object'
);
}
this._params[name] = asParam(parser);
};
Viewer.prototype.importXML = function(xml, bpmnDiagram, done) {
if (isFunction(bpmnDiagram)) {
done = bpmnDiagram;
bpmnDiagram = null;
}
// done is optional
done = done || function() {};
var self = this;
// hook in pre-parse listeners +
// allow xml manipulation
xml = this._emit('import.parse.start', { xml: xml }) || xml;
this._moddle.fromXML(xml, 'bpmn:Definitions', function(err, definitions, context) {
// hook in post parse listeners +
// allow definitions manipulation
definitions = self._emit('import.parse.complete', {
error: err,
definitions: definitions,
context: context
}) || definitions;
var parseWarnings = context.warnings;
if (err) {
err = checkValidationError(err);
self._emit('import.done', { error: err, warnings: parseWarnings });
return done(err, parseWarnings);
}
self._setDefinitions(definitions);
self.open(bpmnDiagram, function(err, importWarnings) {
var allWarnings = [].concat(parseWarnings, importWarnings || []);
self._emit('import.done', { error: err, warnings: allWarnings });
done(err, allWarnings);
});
});
};
Cli.prototype._registerCommand = function(name, Command) {
var command = (
isFunction(Command) ?
this._injector.invoke(Command) :
Command
);
command.args = command.args || [];
this._commands[name] = command;
var self = this;
this[name] = function() {
var args = asArray(arguments);
args.unshift(name);
return self.exec.apply(self, args);
};
};
Viewer.prototype.open = function(bpmnDiagramOrId, done) {
if (isFunction(bpmnDiagramOrId)) {
done = bpmnDiagramOrId;
bpmnDiagramOrId = null;
}
var definitions = this._definitions;
var bpmnDiagram = bpmnDiagramOrId;
// done is optional
done = done || function() {};
if (!definitions) {
return done(new Error('no XML imported'));
}
if (typeof bpmnDiagramOrId === 'string') {
bpmnDiagram = findBPMNDiagram(definitions, bpmnDiagramOrId);
if (!bpmnDiagram) {
return done(new Error('BPMNDiagram <' + bpmnDiagramOrId + '> not found'));
}
}
// clear existing rendered diagram
// catch synchronous exceptions during #clear()
try {
this.clear();
} catch (error) {
return done(error);
}
// perform graphical import
return importBpmnDiagram(this, definitions, bpmnDiagram, done);
};
export function importBpmnDiagram(diagram, definitions, bpmnDiagram, done) {
if (isFunction(bpmnDiagram)) {
done = bpmnDiagram;
bpmnDiagram = null;
}
var importer,
eventBus,
translate;
var error,
warnings = [];
/**
* Walk the diagram semantically, importing (=drawing)
* all elements you encounter.
*
* @param {ModdleElement<Definitions>} definitions
* @param {ModdleElement<BPMNDiagram>} bpmnDiagram
*/
function render(definitions, bpmnDiagram) {
var visitor = {
root: function(element) {
return importer.add(element);
},
element: function(element, parentShape) {
return importer.add(element, parentShape);
},
error: function(message, context) {
warnings.push({ message: message, context: context });
}
};
var walker = new BpmnTreeWalker(visitor, translate);
// traverse BPMN 2.0 document model,
// starting at definitions
walker.handleDefinitions(definitions, bpmnDiagram);
}
try {
importer = diagram.get('bpmnImporter');
eventBus = diagram.get('eventBus');
translate = diagram.get('translate');
eventBus.fire('import.render.start', { definitions: definitions });
render(definitions, bpmnDiagram);
eventBus.fire('import.render.complete', {
error: error,
warnings: warnings
});
} catch (e) {
error = e;
}
done(error, warnings);
}
return function(done) {
var testContainer;
// Make sure the test container is an optional dependency and we fall back
// to an empty <div> if it does not exist.
//
// This is needed if other libraries rely on this helper for testing
// while not adding the mocha-test-container-support as a dependency.
try {
testContainer = TestContainer.get(this);
} catch (e) {
testContainer = document.createElement('div');
document.body.appendChild(testContainer);
}
testContainer.classList.add('test-container');
if (typeof diagram !== 'string') {
options = diagram;
locals = options;
diagram = undefined;
}
var _options = options,
_locals = locals,
_modules;
if (!_locals && isFunction(_options)) {
_locals = _options;
_options = {};
}
if (isFunction(_options)) {
_options = _options();
}
if (isFunction(_locals)) {
_locals = _locals();
}
_modules = (_options || {})._modules || [];
if (_locals) {
var mockModule = {};
forEach(_locals, function(v, k) {
mockModule[k] = ['value', v];
});
_modules = [].concat(_modules, [ mockModule ]);
}
if (_modules.length === 0) {
_modules = undefined;
}
_options = {
container: testContainer,
literalExpression: assign({
modules: _modules || undefined
}, OPTIONS || {}, _options || {})
};
// remove previous instance
if (DMN_JS) {
DMN_JS.destroy();
}
DMN_JS = new DmnJS(_options);
DMN_JS.importXML(diagram, done);
return DMN_JS;
};