vmes-flowable
Version:
ceshibao
1,749 lines (1,399 loc) • 2.63 MB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define([], factory);
else if(typeof exports === 'object')
exports["jeeplus-flowable"] = factory();
else
root["jeeplus-flowable"] = factory();
})((typeof self !== 'undefined' ? self : this), function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ }
/******/ };
/******/
/******/ // define __esModule on exports
/******/ __webpack_require__.r = function(exports) {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 8|1: behave like require
/******/ __webpack_require__.t = function(value, mode) {
/******/ if(mode & 1) value = __webpack_require__(value);
/******/ if(mode & 8) return value;
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ var ns = Object.create(null);
/******/ __webpack_require__.r(ns);
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ return ns;
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = "f928");
/******/ })
/************************************************************************/
/******/ ({
/***/ "0062":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var getBusinessObject = __webpack_require__("599a").getBusinessObject,
is = __webpack_require__("599a").is;
var factory = __webpack_require__("e20b");
var elementHelper = __webpack_require__("a013"),
extensionElementsHelper = __webpack_require__("a71e"),
cmdHelper = __webpack_require__("379d"),
utils = __webpack_require__("a5c9");
var assign = __webpack_require__("5b8b"),
forEach = __webpack_require__("8846"),
find = __webpack_require__("7f0a");
function generatePropertyId() {
return utils.nextId('Property_');
}
/**
* Get all flowable:property objects for a specific business object
*
* @param {ModdleElement} parent
*
* @return {Array<ModdleElement>} a list of flowable:property objects
*/
function getPropertyValues(parent) {
var properties = parent && getPropertiesElement(parent);
if (properties && properties.values) {
return properties.values;
}
return [];
}
/**
* Get all flowable:Properties object for a specific business object
*
* @param {ModdleElement} parent
*
* @return {ModdleElement} a flowable:Properties object
*/
function getPropertiesElement(element) {
if (!isExtensionElements(element)) {
return element.properties;
} else {
return getPropertiesElementInsideExtensionElements(element);
}
}
/**
* Get first flowable:Properties object for a specific bpmn:ExtensionElements
* business object.
*
* @param {ModdleElement} extensionElements
*
* @return {ModdleElement} a flowable:Properties object
*/
function getPropertiesElementInsideExtensionElements(extensionElements) {
return find(extensionElements.values, function(elem) {
return is(elem, 'flowable:Properties');
});
}
/**
* Returns true, if the given business object is a bpmn:ExtensionElements.
*
* @param {ModdleElement} element
*
* @return {boolean} a boolean value
*/
function isExtensionElements(element) {
return is(element, 'bpmn:ExtensionElements');
}
/**
* Create a flowable:property entry using tableEntryFactory
*
* @param {djs.model.Base} element
* @param {BpmnFactory} bpmnFactory
* @param {Object} options
* @param {string} options.id
* @param {Array<string>} options.modelProperties
* @param {Array<string>} options.labels
* @param {function} options.getParent Gets the parent business object
* @param {function} options.show Indicate when the entry will be shown, should return boolean
*/
module.exports = function(element, bpmnFactory, options, translate) {
var getParent = options.getParent;
var modelProperties = options.modelProperties,
createParent = options.createParent;
var bo = getBusinessObject(element);
if (is(element, 'bpmn:Participant')) {
bo = bo.get('processRef');
}
// build properties group only when the participant have a processRef
if (!bo) {
return;
}
assign(options, {
addLabel: translate('Add Property'),
getElements: function(element, node) {
var parent = getParent(element, node, bo);
return getPropertyValues(parent);
},
addElement: function(element, node) {
var commands = [],
parent = getParent(element, node, bo);
if (!parent && typeof createParent === 'function') {
var result = createParent(element, bo);
parent = result.parent;
commands.push(result.cmd);
}
var properties = getPropertiesElement(parent);
if (!properties) {
properties = elementHelper.createElement('flowable:Properties', {}, parent, bpmnFactory);
if (!isExtensionElements(parent)) {
commands.push(cmdHelper.updateBusinessObject(element, parent, { 'properties': properties }));
} else {
commands.push(cmdHelper.addAndRemoveElementsFromList(
element,
parent,
'values',
'extensionElements',
[ properties ],
[]
));
}
}
var propertyProps = {};
forEach(modelProperties, function(prop) {
propertyProps[prop] = undefined;
});
// create id if necessary
if (modelProperties.indexOf('id') >= 0) {
propertyProps.id = generatePropertyId();
}
var property = elementHelper.createElement('flowable:Property', propertyProps, properties, bpmnFactory);
commands.push(cmdHelper.addElementsTolist(element, properties, 'values', [ property ]));
return commands;
},
updateElement: function(element, value, node, idx) {
var parent = getParent(element, node, bo),
property = getPropertyValues(parent)[idx];
forEach(modelProperties, function(prop) {
value[prop] = value[prop] || undefined;
});
return cmdHelper.updateBusinessObject(element, property, value);
},
validate: function(element, value, node, idx) {
// validate id if necessary
if (modelProperties.indexOf('id') >= 0) {
var parent = getParent(element, node, bo),
properties = getPropertyValues(parent),
property = properties[idx];
if (property) {
// check if id is valid
var validationError = utils.isIdValid(property, value.id, translate);
if (validationError) {
return { id: validationError };
}
}
}
},
removeElement: function(element, node, idx) {
var commands = [],
parent = getParent(element, node, bo),
properties = getPropertiesElement(parent),
propertyValues = getPropertyValues(parent),
currentProperty = propertyValues[idx];
commands.push(cmdHelper.removeElementsFromList(element, properties, 'values', null, [ currentProperty ]));
if (propertyValues.length === 1) {
// remove flowable:properties if the last existing property has been removed
if (!isExtensionElements(parent)) {
commands.push(cmdHelper.updateBusinessObject(element, parent, { properties: undefined }));
} else {
forEach(parent.values, function(value) {
if (is(value, 'flowable:Properties')) {
commands.push(extensionElementsHelper.removeEntry(bo, element, value));
}
});
}
}
return commands;
}
});
return factory.table(options);
};
/***/ }),
/***/ "01d5":
/***/ (function(module, exports, __webpack_require__) {
var baseForOwn = __webpack_require__("6138"),
createBaseEach = __webpack_require__("8210");
/**
* The base implementation of `_.forEach` without support for iteratee shorthands.
*
* @private
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @returns {Array|Object} Returns `collection`.
*/
var baseEach = createBaseEach(baseForOwn);
module.exports = baseEach;
/***/ }),
/***/ "020a":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var is = __webpack_require__("599a").is,
entryFactory = __webpack_require__("e20b"),
participantHelper = __webpack_require__("851f"),
getBusinessObject = __webpack_require__("599a").getBusinessObject,
nameEntryFactory = __webpack_require__("57cc"),
utils = __webpack_require__("a5c9");
module.exports = function(group, element, translate, options) {
var businessObject = getBusinessObject(element);
var processIdDescription = options && options.processIdDescription;
if (is(element, 'bpmn:Process') || (is(element, 'bpmn:Participant') && businessObject.get('processRef'))) {
/**
* processId
*/
if (is(element, 'bpmn:Participant')) {
var idEntry = entryFactory.validationAwareTextField({
id: 'process-id',
label: translate('Process Id'),
description: processIdDescription && translate(processIdDescription),
modelProperty: 'processId'
});
// in participants we have to change the default behavior of set and get
idEntry.get = function(element) {
var properties = participantHelper.getProcessBusinessObject(element, 'id');
return { processId: properties.id };
};
idEntry.set = function(element, values) {
return participantHelper.modifyProcessBusinessObject(element, 'id', { id: values.processId });
};
idEntry.validate = function(element, values) {
var idValue = values.processId;
var bo = getBusinessObject(element);
var processIdError = utils.isIdValid(bo.processRef, idValue, translate);
return processIdError ? { processId: processIdError } : {};
};
group.entries.push(idEntry);
/**
* process name
*/
var processNameEntry = nameEntryFactory(element, {
id: 'process-name',
label: translate('Process Name')
})[0];
// in participants we have to change the default behavior of set and get
processNameEntry.get = function(element) {
return participantHelper.getProcessBusinessObject(element, 'name');
};
processNameEntry.set = function(element, values) {
return participantHelper.modifyProcessBusinessObject(element, 'name', values);
};
group.entries.push(processNameEntry);
}
}
};
/***/ }),
/***/ "0418":
/***/ (function(module, exports, __webpack_require__) {
var anObject = __webpack_require__("708d");
var isArrayIteratorMethod = __webpack_require__("5a4f");
var toLength = __webpack_require__("5152");
var bind = __webpack_require__("9d80");
var getIteratorMethod = __webpack_require__("8fcf");
var iteratorClose = __webpack_require__("9cc0");
var Result = function (stopped, result) {
this.stopped = stopped;
this.result = result;
};
module.exports = function (iterable, unboundFunction, options) {
var that = options && options.that;
var AS_ENTRIES = !!(options && options.AS_ENTRIES);
var IS_ITERATOR = !!(options && options.IS_ITERATOR);
var INTERRUPTED = !!(options && options.INTERRUPTED);
var fn = bind(unboundFunction, that, 1 + AS_ENTRIES + INTERRUPTED);
var iterator, iterFn, index, length, result, next, step;
var stop = function (condition) {
if (iterator) iteratorClose(iterator);
return new Result(true, condition);
};
var callFn = function (value) {
if (AS_ENTRIES) {
anObject(value);
return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
} return INTERRUPTED ? fn(value, stop) : fn(value);
};
if (IS_ITERATOR) {
iterator = iterable;
} else {
iterFn = getIteratorMethod(iterable);
if (typeof iterFn != 'function') throw TypeError('Target is not iterable');
// optimisation for array iterators
if (isArrayIteratorMethod(iterFn)) {
for (index = 0, length = toLength(iterable.length); length > index; index++) {
result = callFn(iterable[index]);
if (result && result instanceof Result) return result;
} return new Result(false);
}
iterator = iterFn.call(iterable);
}
next = iterator.next;
while (!(step = next.call(iterator)).done) {
try {
result = callFn(step.value);
} catch (error) {
iteratorClose(iterator);
throw error;
}
if (typeof result == 'object' && result && result instanceof Result) return result;
} return new Result(false);
};
/***/ }),
/***/ "0440":
/***/ (function(module, exports, __webpack_require__) {
var global = __webpack_require__("4c16");
var inspectSource = __webpack_require__("083e");
var WeakMap = global.WeakMap;
module.exports = typeof WeakMap === 'function' && /native code/.test(inspectSource(WeakMap));
/***/ }),
/***/ "04fd":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var nativePropertyIsEnumerable = {}.propertyIsEnumerable;
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
// Nashorn ~ JDK8 bug
var NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1);
// `Object.prototype.propertyIsEnumerable` method implementation
// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
var descriptor = getOwnPropertyDescriptor(this, V);
return !!descriptor && descriptor.enumerable;
} : nativePropertyIsEnumerable;
/***/ }),
/***/ "053b":
/***/ (function(module, exports, __webpack_require__) {
var SetCache = __webpack_require__("32fc"),
arrayIncludes = __webpack_require__("7ce9"),
arrayIncludesWith = __webpack_require__("4c80"),
cacheHas = __webpack_require__("bf8a"),
createSet = __webpack_require__("f837"),
setToArray = __webpack_require__("1f74");
/** Used as the size to enable large array optimizations. */
var LARGE_ARRAY_SIZE = 200;
/**
* The base implementation of `_.uniqBy` without support for iteratee shorthands.
*
* @private
* @param {Array} array The array to inspect.
* @param {Function} [iteratee] The iteratee invoked per element.
* @param {Function} [comparator] The comparator invoked per element.
* @returns {Array} Returns the new duplicate free array.
*/
function baseUniq(array, iteratee, comparator) {
var index = -1,
includes = arrayIncludes,
length = array.length,
isCommon = true,
result = [],
seen = result;
if (comparator) {
isCommon = false;
includes = arrayIncludesWith;
}
else if (length >= LARGE_ARRAY_SIZE) {
var set = iteratee ? null : createSet(array);
if (set) {
return setToArray(set);
}
isCommon = false;
includes = cacheHas;
seen = new SetCache;
}
else {
seen = iteratee ? [] : result;
}
outer:
while (++index < length) {
var value = array[index],
computed = iteratee ? iteratee(value) : value;
value = (comparator || value !== 0) ? value : 0;
if (isCommon && computed === computed) {
var seenIndex = seen.length;
while (seenIndex--) {
if (seen[seenIndex] === computed) {
continue outer;
}
}
if (iteratee) {
seen.push(computed);
}
result.push(value);
}
else if (!includes(seen, computed, comparator)) {
if (seen !== result) {
seen.push(computed);
}
result.push(value);
}
}
return result;
}
module.exports = baseUniq;
/***/ }),
/***/ "0545":
/***/ (function(module, exports) {
if (typeof Object.create === 'function') {
// implementation from standard node.js 'util' module
module.exports = function inherits(ctor, superCtor) {
if (superCtor) {
ctor.super_ = superCtor
ctor.prototype = Object.create(superCtor.prototype, {
constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
}
})
}
};
} else {
// old school shim for old browsers
module.exports = function inherits(ctor, superCtor) {
if (superCtor) {
ctor.super_ = superCtor
var TempCtor = function () {}
TempCtor.prototype = superCtor.prototype
ctor.prototype = new TempCtor()
ctor.prototype.constructor = ctor
}
}
}
/***/ }),
/***/ "0617":
/***/ (function(module, exports, __webpack_require__) {
var getNative = __webpack_require__("85b3"),
root = __webpack_require__("b6b5");
/* Built-in method references that are verified to be native. */
var Set = getNative(root, 'Set');
module.exports = Set;
/***/ }),
/***/ "0623":
/***/ (function(module, exports, __webpack_require__) {
var eq = __webpack_require__("5374");
/**
* Gets the index at which the `key` is found in `array` of key-value pairs.
*
* @private
* @param {Array} array The array to inspect.
* @param {*} key The key to search for.
* @returns {number} Returns the index of the matched value, else `-1`.
*/
function assocIndexOf(array, key) {
var length = array.length;
while (length--) {
if (eq(array[length][0], key)) {
return length;
}
}
return -1;
}
module.exports = assocIndexOf;
/***/ }),
/***/ "064a":
/***/ (function(module, exports, __webpack_require__) {
var arrayEach = __webpack_require__("9b26"),
arrayIncludes = __webpack_require__("7ce9");
/** Used to compose bitmasks for function metadata. */
var WRAP_BIND_FLAG = 1,
WRAP_BIND_KEY_FLAG = 2,
WRAP_CURRY_FLAG = 8,
WRAP_CURRY_RIGHT_FLAG = 16,
WRAP_PARTIAL_FLAG = 32,
WRAP_PARTIAL_RIGHT_FLAG = 64,
WRAP_ARY_FLAG = 128,
WRAP_REARG_FLAG = 256,
WRAP_FLIP_FLAG = 512;
/** Used to associate wrap methods with their bit flags. */
var wrapFlags = [
['ary', WRAP_ARY_FLAG],
['bind', WRAP_BIND_FLAG],
['bindKey', WRAP_BIND_KEY_FLAG],
['curry', WRAP_CURRY_FLAG],
['curryRight', WRAP_CURRY_RIGHT_FLAG],
['flip', WRAP_FLIP_FLAG],
['partial', WRAP_PARTIAL_FLAG],
['partialRight', WRAP_PARTIAL_RIGHT_FLAG],
['rearg', WRAP_REARG_FLAG]
];
/**
* Updates wrapper `details` based on `bitmask` flags.
*
* @private
* @returns {Array} details The details to modify.
* @param {number} bitmask The bitmask flags. See `createWrap` for more details.
* @returns {Array} Returns `details`.
*/
function updateWrapDetails(details, bitmask) {
arrayEach(wrapFlags, function(pair) {
var value = '_.' + pair[0];
if ((bitmask & pair[1]) && !arrayIncludes(details, value)) {
details.push(value);
}
});
return details.sort();
}
module.exports = updateWrapDetails;
/***/ }),
/***/ "0666":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var eventDefinitionReference = __webpack_require__("71cc"),
elementReferenceProperty = __webpack_require__("6e49");
module.exports = function(group, element, bpmnFactory, signalEventDefinition, translate) {
group.entries = group.entries.concat(eventDefinitionReference(element, signalEventDefinition, bpmnFactory, {
label: translate('Signal'),
elementName: 'signal',
elementType: 'bpmn:Signal',
referenceProperty: 'signalRef',
newElementIdPrefix: 'Signal_'
}));
group.entries = group.entries.concat(elementReferenceProperty(element, signalEventDefinition, bpmnFactory, {
id: 'signal-element-name',
label: translate('Signal Name'),
referenceProperty: 'signalRef',
modelProperty: 'name',
shouldValidate: true
}));
};
/***/ }),
/***/ "06ce":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var is = __webpack_require__("599a").is;
var elementHelper = __webpack_require__("a013"),
inputOutputHelper = __webpack_require__("ed1b"),
cmdHelper = __webpack_require__("379d"),
utils = __webpack_require__("a5c9");
var entryFactory = __webpack_require__("e20b"),
scriptImplementation = __webpack_require__("55a1");
function createElement(type, parent, factory, properties) {
return elementHelper.createElement(type, properties, parent, factory);
}
function isScript(elem) {
return is(elem, 'flowable:Script');
}
function isList(elem) {
return is(elem, 'flowable:List');
}
function isMap(elem) {
return is(elem, 'flowable:Map');
}
function ensureInputOutputSupported(element, insideConnector) {
return inputOutputHelper.isInputOutputSupported(element, insideConnector);
}
module.exports = function(element, bpmnFactory, options, translate) {
var typeInfo = {
'flowable:Map': {
value: 'map',
label: translate('Map')
},
'flowable:List': {
value: 'list',
label: translate('List')
},
'flowable:Script': {
value: 'script',
label: translate('Script')
}
};
options = options || {};
var insideConnector = !!options.insideConnector,
idPrefix = options.idPrefix || '';
var getSelected = options.getSelectedParameter;
if (!ensureInputOutputSupported(element, insideConnector)) {
return [];
}
var entries = [];
var isSelected = function(element, node) {
return getSelected(element, node);
};
// parameter name ////////////////////////////////////////////////////////
entries.push(entryFactory.validationAwareTextField({
id: idPrefix + 'parameterName',
label: translate('Name'),
modelProperty: 'name',
getProperty: function(element, node) {
return (getSelected(element, node) || {}).name;
},
setProperty: function(element, values, node) {
var param = getSelected(element, node);
return cmdHelper.updateBusinessObject(element, param, values);
},
validate: function(element, values, node) {
var bo = getSelected(element, node);
var validation = {};
if (bo) {
var nameValue = values.name;
if (nameValue) {
if (utils.containsSpace(nameValue)) {
validation.name = translate('Name must not contain spaces');
}
} else {
validation.name = translate('Parameter must have a name');
}
}
return validation;
},
hidden: function(element, node) {
return !isSelected(element, node);
}
}));
// parameter type //////////////////////////////////////////////////////
var selectOptions = [
{ value: 'text', name: translate('Text') },
{ value: 'script', name: translate('Script') },
{ value: 'list', name: translate('List') },
{ value: 'map', name: translate('Map') }
];
entries.push(entryFactory.selectBox({
id : idPrefix + 'parameterType',
label: translate('Type'),
selectOptions: selectOptions,
modelProperty: 'parameterType',
get: function(element, node) {
var bo = getSelected(element, node);
var parameterType = 'text';
if (typeof bo !== 'undefined') {
var definition = bo.get('definition');
if (typeof definition !== 'undefined') {
var type = definition.$type;
parameterType = typeInfo[type].value;
}
}
return {
parameterType: parameterType
};
},
set: function(element, values, node) {
var bo = getSelected(element, node);
var properties = {
value: undefined,
definition: undefined
};
var createParameterTypeElem = function(type) {
return createElement(type, bo, bpmnFactory);
};
var parameterType = values.parameterType;
if (parameterType === 'script') {
properties.definition = createParameterTypeElem('flowable:Script');
}
else if (parameterType === 'list') {
properties.definition = createParameterTypeElem('flowable:List');
}
else if (parameterType === 'map') {
properties.definition = createParameterTypeElem('flowable:Map');
}
return cmdHelper.updateBusinessObject(element, bo, properties);
},
show: function(element, node) {
return isSelected(element, node);
}
}));
// parameter value (type = text) ///////////////////////////////////////////////////////
entries.push(entryFactory.textBox({
id : idPrefix + 'parameterType-text',
label : translate('Value'),
modelProperty: 'value',
get: function(element, node) {
return {
value: (getSelected(element, node) || {}).value
};
},
set: function(element, values, node) {
var param = getSelected(element, node);
values.value = values.value || undefined;
return cmdHelper.updateBusinessObject(element, param, values);
},
show: function(element, node) {
var bo = getSelected(element, node);
return bo && !bo.definition;
}
}));
// parameter value (type = script) ///////////////////////////////////////////////////////
var script = scriptImplementation('scriptFormat', 'value', true, translate);
entries.push({
id: idPrefix + 'parameterType-script',
html: '<div data-show="isScript">' +
script.template +
'</div>',
get: function(element, node) {
var bo = getSelected(element, node);
return bo && isScript(bo.definition) ? script.get(element, bo.definition) : {};
},
set: function(element, values, node) {
var bo = getSelected(element, node);
var update = script.set(element, values);
return cmdHelper.updateBusinessObject(element, bo.definition, update);
},
validate: function(element, values, node) {
var bo = getSelected(element, node);
return bo && isScript(bo.definition) ? script.validate(element, bo.definition) : {};
},
isScript: function(element, node) {
var bo = getSelected(element, node);
return bo && isScript(bo.definition);
},
script: script
});
// parameter value (type = list) ///////////////////////////////////////////////////////
entries.push(entryFactory.table({
id: idPrefix + 'parameterType-list',
modelProperties: [ 'value' ],
labels: [ translate('Value') ],
addLabel: translate('Add Value'),
getElements: function(element, node) {
var bo = getSelected(element, node);
if (bo && isList(bo.definition)) {
return bo.definition.items;
}
return [];
},
updateElement: function(element, values, node, idx) {
var bo = getSelected(element, node);
var item = bo.definition.items[idx];
return cmdHelper.updateBusinessObject(element, item, values);
},
addElement: function(element, node) {
var bo = getSelected(element, node);
var newValue = createElement('flowable:Value', bo.definition, bpmnFactory, { value: undefined });
return cmdHelper.addElementsTolist(element, bo.definition, 'items', [ newValue ]);
},
removeElement: function(element, node, idx) {
var bo = getSelected(element, node);
return cmdHelper.removeElementsFromList(element, bo.definition, 'items', null, [ bo.definition.items[idx] ]);
},
editable: function(element, node, prop, idx) {
var bo = getSelected(element, node);
var item = bo.definition.items[idx];
return !isMap(item) && !isList(item) && !isScript(item);
},
setControlValue: function(element, node, input, prop, value, idx) {
var bo = getSelected(element, node);
var item = bo.definition.items[idx];
if (!isMap(item) && !isList(item) && !isScript(item)) {
input.value = value;
} else {
input.value = typeInfo[item.$type].label;
}
},
show: function(element, node) {
var bo = getSelected(element, node);
return bo && bo.definition && isList(bo.definition);
}
}));
// parameter value (type = map) ///////////////////////////////////////////////////////
entries.push(entryFactory.table({
id: idPrefix + 'parameterType-map',
modelProperties: [ 'key', 'value' ],
labels: [ translate('Key'), translate('Value') ],
addLabel: translate('Add Entry'),
getElements: function(element, node) {
var bo = getSelected(element, node);
if (bo && isMap(bo.definition)) {
return bo.definition.entries;
}
return [];
},
updateElement: function(element, values, node, idx) {
var bo = getSelected(element, node);
var entry = bo.definition.entries[idx];
if (isMap(entry.definition) || isList(entry.definition) || isScript(entry.definition)) {
values = {
key: values.key
};
}
return cmdHelper.updateBusinessObject(element, entry, values);
},
addElement: function(element, node) {
var bo = getSelected(element, node);
var newEntry = createElement('flowable:Entry', bo.definition, bpmnFactory, { key: undefined, value: undefined });
return cmdHelper.addElementsTolist(element, bo.definition, 'entries', [ newEntry ]);
},
removeElement: function(element, node, idx) {
var bo = getSelected(element, node);
return cmdHelper.removeElementsFromList(element, bo.definition, 'entries', null, [ bo.definition.entries[idx] ]);
},
editable: function(element, node, prop, idx) {
var bo = getSelected(element, node);
var entry = bo.definition.entries[idx];
return prop === 'key' || (!isMap(entry.definition) && !isList(entry.definition) && !isScript(entry.definition));
},
setControlValue: function(element, node, input, prop, value, idx) {
var bo = getSelected(element, node);
var entry = bo.definition.entries[idx];
if (prop === 'key' || (!isMap(entry.definition) && !isList(entry.definition) && !isScript(entry.definition))) {
input.value = value;
} else {
input.value = typeInfo[entry.definition.$type].label;
}
},
show: function(element, node) {
var bo = getSelected(element, node);
return bo && bo.definition && isMap(bo.definition);
}
}));
return entries;
};
/***/ }),
/***/ "079c":
/***/ (function(module, exports, __webpack_require__) {
var isArrayLike = __webpack_require__("9072"),
isObjectLike = __webpack_require__("4923");
/**
* This method is like `_.isArrayLike` except that it also checks if `value`
* is an object.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an array-like object,
* else `false`.
* @example
*
* _.isArrayLikeObject([1, 2, 3]);
* // => true
*
* _.isArrayLikeObject(document.body.children);
* // => true
*
* _.isArrayLikeObject('abc');
* // => false
*
* _.isArrayLikeObject(_.noop);
* // => false
*/
function isArrayLikeObject(value) {
return isObjectLike(value) && isArrayLike(value);
}
module.exports = isArrayLikeObject;
/***/ }),
/***/ "07cd":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var inherits = __webpack_require__("0545");
var PropertiesActivator = __webpack_require__("5361");
var asyncCapableHelper = __webpack_require__("718c"),
ImplementationTypeHelper = __webpack_require__("286f");
var is = __webpack_require__("599a").is;
// bpmn properties
var processProps = __webpack_require__("020a"),
eventProps = __webpack_require__("4c31"),
linkProps = __webpack_require__("e05e"),
documentationProps = __webpack_require__("3e80"),
idProps = __webpack_require__("138b"),
nameProps = __webpack_require__("92f8"),
executableProps = __webpack_require__("980d");
// flowable properties
var serviceTaskDelegateProps = __webpack_require__("0fd9"),
userTaskProps = __webpack_require__("78e4"),
asynchronousContinuationProps = __webpack_require__("95b9"),
callActivityProps = __webpack_require__("37d7"),
multiInstanceProps = __webpack_require__("eeb1"),
conditionalProps = __webpack_require__("395b"),
scriptProps = __webpack_require__("1893"),
errorProps = __webpack_require__("7835"),
formProps = __webpack_require__("94b7"),
startEventInitiator = __webpack_require__("7fab"),
variableMapping = __webpack_require__("cbe8"),
versionTag = __webpack_require__("4b64");
var listenerProps = __webpack_require__("33fc"),
listenerDetails = __webpack_require__("a9d4"),
listenerFields = __webpack_require__("8aa8");
var elementTemplateChooserProps = __webpack_require__("ed85"),
elementTemplateCustomProps = __webpack_require__("138d");
// Input/Output
var inputOutput = __webpack_require__("b760"),
inputOutputParameter = __webpack_require__("a1bb");
// Connector
var connectorDetails = __webpack_require__("0c02"),
connectorInputOutput = __webpack_require__("9e73"),
connectorInputOutputParameter = __webpack_require__("5421");
// properties
var properties = __webpack_require__("31a9");
// properties
var buttons = __webpack_require__("544d");
// job configuration
var jobConfiguration = __webpack_require__("fbb5");
// history time to live
var historyTimeToLive = __webpack_require__("dba1");
// candidate starter groups/users
var candidateStarter = __webpack_require__("a518");
// tasklist
var tasklist = __webpack_require__("97cc");
// external task configuration
var externalTaskConfiguration = __webpack_require__("6ca8");
// field injection
var fieldInjections = __webpack_require__("af82");
var getBusinessObject = __webpack_require__("599a").getBusinessObject,
eventDefinitionHelper = __webpack_require__("4d3c"),
implementationTypeHelper = __webpack_require__("286f");
// helpers ////////////////////////////////////////
var isExternalTaskPriorityEnabled = function(element) {
var businessObject = getBusinessObject(element);
// show only if element is a process, a participant ...
if (is(element, 'bpmn:Process') || is(element, 'bpmn:Participant') && businessObject.get('processRef')) {
return true;
}
var externalBo = ImplementationTypeHelper.getServiceTaskLikeBusinessObject(element),
isExternalTask = ImplementationTypeHelper.getImplementationType(externalBo) === 'external';
// ... or an external task with selected external implementation type
return !!ImplementationTypeHelper.isExternalCapable(externalBo) && isExternalTask;
};
var isJobConfigEnabled = function(element) {
var businessObject = getBusinessObject(element);
if (is(element, 'bpmn:Process') || is(element, 'bpmn:Participant') && businessObject.get('processRef')) {
return true;
}
// async behavior
var bo = getBusinessObject(element);
if (asyncCapableHelper.isAsyncBefore(bo) || asyncCapableHelper.isAsyncAfter(bo)) {
return true;
}
// timer definition
if (is(element, 'bpmn:Event')) {
return !!eventDefinitionHelper.getTimerEventDefinition(element);
}
return false;
};
var getInputOutputParameterLabel = function(param, translate) {
if (is(param, 'flowable:InputParameter')) {
return translate('Input Parameter');
}
if (is(param, 'flowable:OutputParameter')) {
return translate('Output Parameter');
}
return '';
};
var getListenerLabel = function(param, translate) {
if (is(param, 'flowable:ExecutionListener')) {
return translate('Execution Listener');
}
if (is(param, 'flowable:TaskListener')) {
return translate('Task Listener');
}
return '';
};
var PROCESS_KEY_HINT = 'This maps to the process definition key.';
var TASK_KEY_HINT = 'This maps to the task definition key.';
function createGeneralTabGroups(
element, canvas, bpmnFactory,
elementRegistry, elementTemplates, translate) {
// refer to target element for external labels
element = element.labelTarget || element;
var generalGroup = {
id: 'general',
label: translate('General'),
entries: []
};
var idOptions;
var processOptions;
if (is(element, 'bpmn:Process')) {
idOptions = { description: PROCESS_KEY_HINT };
}
if (is(element, 'bpmn:UserTask')) {
idOptions = { description: TASK_KEY_HINT };
}
if (is(element, 'bpmn:Participant')) {
processOptions = { processIdDescription: PROCESS_KEY_HINT };
}
idProps(generalGroup, element, translate, idOptions);
nameProps(generalGroup, element, bpmnFactory, canvas, translate);
processProps(generalGroup, element, translate, processOptions);
versionTag(generalGroup, element, translate);
executableProps(generalGroup, element, translate);
elementTemplateChooserProps(generalGroup, element, elementTemplates, translate);
var customFieldsGroups = elementTemplateCustomProps(element, elementTemplates, bpmnFactory, translate);
var detailsGroup = {
id: 'details',
label: translate('Details'),
entries: []
};
serviceTaskDelegateProps(detailsGroup, element, bpmnFactory, translate);
userTaskProps(detailsGroup, element, translate);
scriptProps(detailsGroup, element, bpmnFactory, translate);
linkProps(detailsGroup, element, translate);
callActivityProps(detailsGroup, element, bpmnFactory, translate);
eventProps(detailsGroup, element, bpmnFactory, elementRegistry, translate);
errorProps(detailsGroup, element, bpmnFactory, translate);
conditionalProps(detailsGroup, element, bpmnFactory, translate);
startEventInitiator(detailsGroup, element, translate); // this must be the last element of the details group!
var multiInstanceGroup = {
id: 'multiInstance',
label: translate('Multi Instance'),
entries: []
};
multiInstanceProps(multiInstanceGroup, element, bpmnFactory, translate);
var asyncGroup = {
id : 'async',
label: translate('Asynchronous Continuations'),
entries : []
};
asynchronousContinuationProps(asyncGroup, element, bpmnFactory, translate);
var jobConfigurationGroup = {
id : 'jobConfiguration',
label : translate('Job Configuration'),
entries : [],
enabled: isJobConfigEnabled
};
jobConfiguration(jobConfigurationGroup, element, bpmnFactory, translate);
var externalTaskGroup = {
id : 'externalTaskConfiguration',
label : translate('External Task Configuration'),
entries : [],
enabled: isExternalTaskPriorityEnabled
};
externalTaskConfiguration(externalTaskGroup, element, bpmnFactory, translate);
var candidateStarterGroup = {
id: 'candidateStarterConfiguration',
label: translate('Candidate Starter Configuration'),
entries: []
};
candidateStarter(candidateStarterGroup, element, bpmnFactory, translate);
var historyTimeToLiveGroup = {
id: 'historyConfiguration',
label: translate('History Configuration'),
entries: []
};
historyTimeToLive(historyTimeToLiveGroup, element, bpmnFactory, translate);
var tasklistGroup = {
id: 'tasklist',
label: translate('Tasklist Configuration'),
entries: []
};
tasklist(tasklistGroup, element, bpmnFactory, translate);
var documentationGroup = {
id: 'documentation',
label: translate('Documentation'),
entries: []
};
documentationProps(documentationGroup, element, bpmnFactory, translate);
var groups = [];
groups.push(generalGroup);
customFieldsGroups.forEach(function(group) {
groups.push(group);
});
groups.push(detailsGroup);
groups.push(externalTaskGroup);
groups.push(multiInstanceGroup);
groups.push(asyncGroup);
groups.push(jobConfigurationGroup);
groups.push(candidateStarterGroup);
groups.push(historyTimeToLiveGroup);
groups.push(tasklistGroup);
groups.push(documentationGroup);
return groups;
}
function createVariablesTabGroups(element, bpmnFactory, elementRegistry, translate) {
var variablesGroup = {
id : 'variables',
label : translate('Variables'),
entries: []
};
variableMapping(variablesGroup, element, bpmnFactory, translate);
return [
variablesGroup
];
}
function createFormsTabGroups(element, bpmnFactory, elementRegistry, translate) {
var formGroup = {
id : 'forms',
label : translate('Forms'),
entries: []
};
formProps(formGroup, element, bpmnFactory, translate);
return [
formGroup
];
}
function createListenersTabGroups(element, bpmnFactory, elementRegistry, translate) {
var listenersGroup = {
id : 'listeners',
label: translate('Listeners'),
entries: []
};
var options = listenerProps(listenersGroup, element, bpmnFactory, translate);
var listenerDetailsGroup = {
id: 'listener-details',
entries: [],
enabled: function(element, node) {
return options.getSelectedListener(element, node);
},
label: function(element, node) {
var param = options.getSelectedListener(element, node);
return getListenerLabel(param, translate);
}
};
listenerDetails(listenerDetailsGroup, element, bpmnFactory, options, translate);
var listenerFieldsGroup = {
id: 'listener-fields',
label: translate('Field Injection'),
entries: [],
enabled: function(element, node) {
return options.getSelectedListener(element, node);
}
};
listenerFields(listenerFieldsGroup, element, bpmnFactory, options, translate);
return [
listenersGroup,
listenerDetailsGroup,
listenerFieldsGroup
];
}
function createInputOutputTabGroups(element, bpmnFactory, elementRegistry, translate) {
var inputOutputGroup = {
id: 'input-output',
label: translate('Parameters'),
entries: []
};
var options = inputOutput(inputOutputGroup, element, bpmnFactory, translate);
var inputOutputParameterGroup = {
id: 'input-output-parameter',
entries: [],
enabled: function(element, node) {
return options.getSelectedParameter(element, node);
},
label: function(element, node) {
var param = options.getSelectedParameter(element, node);
return getInputOutputParameterLabel(param, translate);
}
};
inputOutputParameter(inputOutputParameterGroup, element, bpmnFactory, options, translate);
return [
inputOutputGroup,
inputOutputParameterGroup
];
}
function createConnectorTabGroups(element, bpmnFactory, elementRegistry, translate) {
var connectorDetailsGroup = {
id: 'connector-details',
label: translate('Details'),
entries: []
};
connectorDetails(connectorDetailsGroup, element, bpmnFactory, translate);
var connectorInputOutputGroup = {
id: 'connector-input-output',
label: translate('Input/Output'),
entries: []
};
var options = connectorInputOutput(connectorInputOutputGroup, element, bpmnFactory, translate);
var connectorInputOutputParameterGroup = {
id: 'connector-input-output-parameter',
entries: [],
enabled: function(element, node) {
return options.getSelectedParameter(element, node);
},
label: function(element, node) {
var param = options.getSelectedParameter(element, node);
return getInputOutputParameterLabel(param, translate);
}
};
connectorInputOutputParameter(connectorInputOutputParameterGroup, element, bpmnFactory, options, translate);
return [
connectorDetailsGroup,
connectorInputOutputGroup,
connectorInputOutputParameterGroup
];
}
function createFieldInjectionsTabGroups(element, bpmnFactory, elementRegistry, translate) {
var fieldGroup = {
id: 'field-injections-properties',
label: translate('Field Injections'),
entries: []
};
fieldInjections(fieldGroup, element, bpmnFactory, translate);
return [
fieldGroup
];
}
function createExtensionElementsGroups(element, bpmnFactory, elementRegistry, translate) {
var propertiesGroup = {
id : 'extensionElements-properties',
label: translate('Properties'),
entries: []
};
properties(propertiesGroup, element, bpmnFactory, translate);
return [
propertiesGroup
];
}
function createButtonsTabGroups(element, bpmnFactory, elementRegistry, translate) {
var buttonsGroup = {
id : 'buttons-properties',
label: translate('Buttons'),
entries: []
};
buttons(buttonsGroup, element, bpmnFactory, translate);
return [
buttonsGroup
];
}
// Flowable Properties Provider /////////////////////////////////////
/**
* A properties provider for Flowable related properties.
*
* @param {EventBus} eventBus
* @param {Canvas} canvas
* @param {BpmnFactory} bpmnFactory
* @param {ElementRegistry} elementRegistry
* @param {ElementTemplates} elementTemplates
* @param {Translate} translate
*/
function FlowablePropertiesProvider(
eventBus, canvas, bpmnFactory,
elementRegistry, elementTemplates, translate) {
PropertiesActivator.call(this, eventBus);
this.getTabs = function(element) {
var generalTab = {
id: 'general',
label: translate('General'),
groups: createGeneralTabGroups(
element, canvas, bpmnFactory,
elementRegistry, elementTemplates, translate)
};
var variablesTab = {
id: 'variables',
label: translate('Variables'),
groups: createVariablesTabGroups(element, bpmnFactory, elementRegistry, translate)
};
var formsTab = {
id: 'forms',
label: translate('Forms'),
groups: createFormsTabGroups(element, bpmnFactory, elementRegistry, translate)
};
var listenersTab = {
id: 'listeners',
label: translate('Listeners'),
groups: createListenersTabGroups(element, bpmnFactory, elementRegistry, translate),
enabled: function(element) {
return !eventDefinitionHelper.getLinkEventDefinition(element)
|| (!is(element, 'bpmn:IntermediateThrowEvent')
&& eventDefinitionHelper.getLinkEventDefinition(element));
}
};
var inputOutputTab = {
id: 'input-output',
label: translate('Input/Output'),
groups: createInputOutputTabGroups(element, bpmnFactory, elementRegistry, translate)
};
var buttonTab = {
id: 'button-tab',
label: translate('Buttons Settings'),
groups: createButtonsTabGroups(element, bpmnFactory, elementRegistry, translate)
};
var connectorTab = {
id: 'connector',
label: translate('Connector'),
groups: createConnectorTabGroups(element, bpmnFactory, elementRegistry, translate),
enabled: function(element) {
var bo = implementationTypeHelper.getServiceTaskLikeBusinessObject(element);
return bo && implementationTypeHelper.getImplementationType(bo) === 'connector';
}
};
var fieldInjectionsTab = {
id: 'field-injections',
label: translate('Field Injections'),
groups: createFieldInjectionsTabGroups(element, bpmnFactory, elementRegistry, translate)
};
var extensionsTab = {
id: 'extensionElements',
label: translate('Extensions'),
groups: createExtensionElementsGroups(element, bpmnFactory, elementRegistry, translate)
};
return [
generalTab,
variablesTab,
connectorTab,
formsTab,
listenersTab,
inputOutputTab,
buttonTab,
fieldInjectionsTab,
extensionsTab
];
};
}
FlowablePropertiesProvider.$inject = [
'eventBus',
'canvas',
'bpmnFactory',
'elementRegistry',
'elementTemplates',
'translate'
];
inherits(FlowablePropertiesProvider, PropertiesActivator);
module.exports = FlowablePropertiesProvider;
/***/ }),
/***/ "083c":
/***/ (function(module, exports, __webpack_require__) {
var assocIndexOf = __webpack_require__("0623");
/**
* Sets the list cache `key` to `value`.
*
* @pr