@processmaker/modeler 1.32.0 → 1.34.0

package/src/components/modeler/ModelerReadonly.vue

@@ -1,1011 +0,0 @@
-<template>
-  <span data-test="body-container">
-    <div class="modeler h-100">
-      <controls
-        v-if="showControls"
-        class="controls h-100 rounded-0 border-top-0 border-bottom-0 border-left-0"
-        :nodeTypes="nodeTypes"
-        :compressed="panelsCompressed"
-        :parent-height="parentHeight"
-        :allowDrop="allowDrop"
-        :canvas-drag-position="canvasDragPosition"
-        @drag="validateDropTarget"
-        @handleDrop="handleDrop"
-      />
-      <b-col
-        ref="paper-container"
-        class="paper-container h-100 pr-4"
-        :class="[cursor, { 'grabbing-cursor' : isGrabbing }]"
-        :style="{ width: parentWidth, height: parentHeight }"
-      >
-
-        <div ref="paper" data-test="paper" class="main-paper" />
-      </b-col>
-
-      <component
-        ref="nodeComponent"
-        v-for="node in nodes"
-        :is="node.type"
-        :key="node._modelerId"
-        :graph="graph"
-        :paper="paper"
-        :node="node"
-        :id="node.id"
-        :border-outline="borderOutline(node.id)"
-        :collaboration="collaboration"
-        :process-node="processNode"
-        :processes="processes"
-        :plane-elements="planeElements"
-        :moddle="moddle"
-        :nodeRegistry="nodeRegistry"
-        :root-elements="definitions.get('rootElements')"
-        :paperManager="paperManager"
-        :auto-validate="autoValidate"
-        :node-id-generator="nodeIdGenerator"
-        :highlighted="highlightedNodes.includes(node)"
-        :is-active="node === activeNode"
-        :is-rendering="isRendering"
-        :is-completed="requestCompletedNodes.includes(node.definition.id)"
-        :is-in-progress="requestInProgressNodes.includes(node.definition.id)"
-        @add-node="addNode"
-        @set-cursor="cursor = $event"
-        @set-pool-target="poolTarget = $event"
-        @unset-pools="unsetPools"
-        @clearSelection="clearSelection"
-        @set-pools="setPools"
-        @set-shape-stacking="setShapeStacking"
-        @default-flow="toggleDefaultFlow"
-      />
-
-      <div class="rail-container">
-        <div class="rail-left">
-          <ZoomControl
-            :paper-manager="paperManager"
-          />
-        </div>
-      </div>
-
-      <Selection
-        v-if="paper"
-        ref="selector"
-        :graph="graph"
-        :paperManager="paperManager"
-        :useModelGeometry="false"
-        :processNode="processNode"
-      />
-    </div>
-  </span>
-</template>
-
-<script>
-import Vue from 'vue';
-import _ from 'lodash';
-import { dia } from 'jointjs';
-import boundaryEventConfig from '../nodes/boundaryEvent';
-import BpmnModdle from 'bpmn-moddle';
-import controls from '../controls/controls';
-import pull from 'lodash/pull';
-import remove from 'lodash/remove';
-import store from '@/store';
-import undoRedoStore from '@/undoRedoStore';
-import { Linter } from 'bpmnlint';
-import linterConfig from '../../../.bpmnlintrc';
-import { getNodeIdGenerator } from '../../NodeIdGenerator';
-import Process from '../inspectors/process';
-import runningInCypressTest from '@/runningInCypressTest';
-import getValidationProperties from '@/targetValidationUtils';
-import { id as laneId } from '@/components/nodes/poolLane/config';
-import { id as sequenceFlowId } from '../nodes/sequenceFlow';
-import { id as associationId } from '../nodes/association';
-import { id as messageFlowId } from '../nodes/messageFlow/config';
-import { id as dataOutputAssociationFlowId } from '../nodes/dataOutputAssociation/config';
-import { id as dataInputAssociationFlowId } from '../nodes/dataInputAssociation/config';
-import { id as genericFlowId } from '@/components/nodes/genericFlow/config';
-
-import PaperManager from '../paperManager';
-import registerInspectorExtension from '@/components/InspectorExtensionManager';
-
-import ensureShapeIsNotCovered from '@/components/shapeStackUtils';
-import Node from '@/components/nodes/node';
-import { addNodeToProcess } from '@/components/nodeManager';
-import TimerEventNode from '@/components/nodes/timerEventNode';
-import focusNameInputAndHighlightLabel from '@/components/modeler/focusNameInputAndHighlightLabel';
-import XMLManager from '@/components/modeler/XMLManager';
-import { NodeMigrator } from '@/components/modeler/NodeMigrator';
-import addLoopCharacteristics from '@/setup/addLoopCharacteristics';
-import Selection from './Selection';
-import ZoomControl from '@/components/railBottom/zoomControl/ZoomControl.vue';
-
-export default {
-  components: {
-    controls,
-    Selection,
-    ZoomControl,
-  },
-  props: {
-    owner: Object,
-    decorations: {
-      type: Object,
-      default() {
-        return {};
-      },
-    },
-    readOnly: {
-      type: Boolean,
-      default: true,
-    },
-    requestCompletedNodes: {
-      type: Array,
-      default: () => [],
-    },
-    requestInProgressNodes: {
-      type: Array,
-      default: () => [],
-    },
-  },
-  data() {
-    return {
-      pasteInProgress: false,
-      cloneInProgress: false,
-      internalClipboard: [],
-
-      /* Custom parsers for handling certain bpmn node types */
-      parsers: {},
-
-      // What bpmn moddle extensions should we register
-      extensions: [],
-      // Our node types, keyed by the id
-      nodeRegistry: {},
-
-      // Our jointjs data graph model
-      graph: null,
-      paper: null,
-      paperManager: null,
-
-      definitions: null,
-      nodeIdGenerator: null,
-      planeElements: null,
-      canvasDragPosition: null,
-      processNode: null,
-      collaboration: null,
-      moddle: null,
-      allowDrop: true,
-      poolTarget: null,
-      processes: [],
-      cursor: null,
-      parentHeight: null,
-      parentWidth: null,
-      linter: null,
-      validationErrors: {},
-      miniMapOpen: false,
-      panelsCompressed: false,
-      isGrabbing: false,
-      isRendering: false,
-      allWarnings: [],
-      nodeTypes: [],
-      activeNode: null,
-      xmlManager: null,
-      previouslyStackedShape: null,
-      canvasScale: 1,
-      initialScale: 1,
-      minimumScale: 0.2,
-      scaleStep: 0.1,
-      isDragging: false,
-      isSelecting: false,
-      isIntoTheSelection: false,
-      dragStart: null,
-    };
-  },
-  watch: {
-    isRendering() {
-      const loadingMessage = 'Loading process, please be patient.';
-
-      if (this.isRendering) {
-        window.ProcessMaker.alert(loadingMessage, 'warning');
-        document.body.style.cursor = 'wait !important';
-        this.cursor = 'wait';
-        return;
-      }
-
-      window.ProcessMaker.navbar.alerts = window.ProcessMaker.navbar.alerts.filter(alert => {
-        return alert.alertText !== loadingMessage;
-      });
-      document.body.style.cursor = 'auto';
-      this.cursor = null;
-    },
-    currentXML() {
-      this.validateIfAutoValidateIsOn();
-    },
-    definitions() {
-      this.validateIfAutoValidateIsOn();
-    },
-    autoValidate() {
-      this.validateIfAutoValidateIsOn();
-    },
-    canvasScale(canvasScale) {
-      this.paperManager.scale = canvasScale;
-    },
-  },
-  computed: {
-    showControls() {
-      return !this.readOnly;
-    },
-    autoValidate: () => store.getters.autoValidate,
-    nodes: () => store.getters.nodes,
-    currentXML() {
-      return undoRedoStore.getters.currentState;
-    },
-    /* connectors expect a highlightedNode property */
-    highlightedNode: () => store.getters.highlightedNodes[0],
-    highlightedNodes: () => store.getters.highlightedNodes,
-  },
-  methods: {
-    toggleDefaultFlow(flow) {
-      const source = flow.definition.sourceRef;
-      if (source.default && source.default.id === flow.id) {
-        flow = null;
-      }
-      source.set('default', flow);
-    },
-    borderOutline(nodeId) {
-      return this.decorations.borderOutline && this.decorations.borderOutline[nodeId];
-    },
-    cleanPlaneElements() {
-      remove(this.planeElements, diagram => !diagram.bpmnElement);
-    },
-    validateIfAutoValidateIsOn() {
-      if (this.autoValidate) {
-        this.validateBpmnDiagram();
-      }
-    },
-    translateConfig(inspectorConfig) {
-      if (inspectorConfig.config) {
-        const config = inspectorConfig.config;
-
-        config.label = this.$t(config.label);
-        config.helper = this.$t(config.helper);
-      }
-
-      if (inspectorConfig.items) {
-        inspectorConfig.items.forEach(this.translateConfig);
-      }
-    },
-    getXmlFromDiagram() {
-      return new Promise((resolve, reject) => {
-        this.toXML((error, xml) => {
-          if (error) {
-            reject(error);
-          } else {
-            resolve(xml);
-          }
-        });
-      });
-    },
-    async validateBpmnDiagram() {
-      if (!store.getters.globalProcesses || store.getters.globalProcesses.length === 0) {
-        await store.dispatch('fetchGlobalProcesses');
-      }
-      this.validationErrors = await this.linter.lint(this.definitions);
-      this.$emit('validate', this.validationErrors);
-    },
-    setPools(poolDefinition) {
-      if (!this.collaboration) {
-        this.collaboration = this.moddle.create('bpmn:Collaboration');
-        this.definitions.get('rootElements').push(this.collaboration);
-        this.collaboration.set('id', 'collaboration_0');
-        this.plane.set('bpmnElement', this.collaboration);
-      }
-
-      if (poolDefinition.get('processRef')) {
-        if (!this.collaboration.get('participants').includes(poolDefinition)) {
-          this.collaboration.get('participants').push(poolDefinition);
-        }
-
-        return;
-      }
-
-      let process;
-      if (this.collaboration.get('participants').length === 0) {
-        process = this.processNode.definition;
-      } else {
-        process = this.moddle.create('bpmn:Process');
-        this.processes.push(process);
-        process.set('id', `process_${this.processes.length}`);
-
-        this.definitions.get('rootElements').push(process);
-      }
-
-      poolDefinition.set('processRef', process);
-      this.collaboration.get('participants').push(poolDefinition);
-    },
-    unsetPools() {
-      pull(this.definitions.get('rootElements'), this.collaboration);
-      this.plane.set('bpmnElement', this.processNode.definition);
-      this.collaboration = null;
-    },
-    highlightNode(node, event) {
-      if (!node || !this.highlightedNode) {
-        return;
-      }
-
-      if (event && event.shiftKey) {
-        store.commit('addToHighlightedNodes', [node]);
-        return;
-      }
-
-      let isSameHighlightedNode = _.isEqual(node.id, this.highlightedNode.id);
-
-      if (!isSameHighlightedNode) {
-        store.commit('highlightNode', node);
-      }
-
-      return;
-    },
-    blurFocusedScreenBuilderElement() {
-      const elementsToBlur = ['INPUT', 'SELECT'];
-      if (elementsToBlur.includes(document.activeElement && document.activeElement.tagName)) {
-        document.activeElement.blur();
-      }
-    },
-    registerStatusBar(component) {
-      this.owner.validationBar.push(component);
-    },
-    /**
-     * Register a mixin into a node component.
-     * Used during "modeler-before-init"
-     *
-     */
-    registerComponentMixin(component, mixin) {
-      if (!component.mixins) {
-        component.mixins = [];
-      }
-      component.mixins.push(mixin);
-    },
-    /**
-     * Register a BPMN Moddle extension in order to support extensions to the bpmn xml format.
-     * This is used to support new attributes and elements that would be needed for specific
-     * bpmn execution environments.
-     */
-    registerBpmnExtension(namespace, extension) {
-      this.extensions[namespace] = extension;
-    },
-    registerNode(nodeType, customParser) {
-      const defaultParser = () => nodeType.id;
-      const implementationParser = definition => {
-        if (definition.get('implementation') === nodeType.implementation) {
-          return nodeType.id;
-        }
-        return undefined;
-      };
-
-      this.translateConfig(nodeType.inspectorConfig[0]);
-      addLoopCharacteristics(nodeType);
-      this.nodeRegistry[nodeType.id] = nodeType;
-
-      Vue.component(nodeType.id, nodeType.component);
-      this.nodeTypes.push(nodeType);
-
-      const types = Array.isArray(nodeType.bpmnType)
-        ? nodeType.bpmnType
-        : [nodeType.bpmnType];
-
-      types.forEach(bpmnType => {
-        if (!this.parsers[bpmnType]) {
-          this.parsers[bpmnType] = { custom: [], implementation: [], default: []};
-        }
-
-        if (customParser) {
-          this.parsers[bpmnType].custom.push(customParser);
-          return;
-        }
-
-        if (nodeType.implementation) {
-          this.parsers[bpmnType].implementation.push(implementationParser);
-          return;
-        }
-
-        this.parsers[bpmnType].default.push(defaultParser);
-      });
-    },
-    addMessageFlows() {
-      if (this.collaboration) {
-        this.collaboration
-          .get('messageFlows')
-          .filter(this.hasSourceAndTarget)
-          .forEach(this.setNode);
-      }
-    },
-    loadAssociations(flowElements, artifacts) {
-      artifacts
-        .filter(definition => definition.$type === 'bpmn:Association' && this.hasSourceAndTarget(definition))
-        .forEach(definition => this.setNode(definition, flowElements, artifacts));
-    },
-    loadDataAssociations(flowElements) {
-      const tasksThatHaveDataOutputAssociations = flowElements.filter(task => task.get('dataOutputAssociations') &&
-          task.get('dataOutputAssociations').length > 0);
-
-      tasksThatHaveDataOutputAssociations.forEach(task => {
-        task.get('dataOutputAssociations').forEach(dataAssociationLink => {
-          this.setNode(dataAssociationLink, flowElements);
-        });
-      });
-
-      const tasksThatHaveDataInputAssociations = flowElements.filter(task => task.get('dataInputAssociations') &&
-          task.get('dataInputAssociations').length > 0);
-
-      tasksThatHaveDataInputAssociations.forEach(task => {
-        task.get('dataInputAssociations').forEach(dataAssociationLink => {
-          this.setNode(dataAssociationLink, flowElements);
-        });
-      });
-    },
-    loadArtifacts(flowElements, artifacts) {
-      artifacts
-        .filter(definition => definition.$type !== 'bpmn:Association')
-        .forEach(definition => this.setNode(definition, flowElements, artifacts));
-    },
-    loadSequenceFlows(flowElements, artifacts) {
-      flowElements
-        .filter(definition => definition.$type === 'bpmn:SequenceFlow' && this.hasSourceAndTarget(definition))
-        .forEach(definition => this.setNode(definition, flowElements, artifacts));
-    },
-    loadFlowElements(flowElements, artifacts) {
-      flowElements
-        .filter(definition => definition.$type !== 'bpmn:SequenceFlow')
-        .forEach(definition => this.setNode(definition, flowElements, artifacts));
-    },
-    addLanes(process) {
-      if (process.get('laneSets')[0]) {
-        process.laneSets[0].lanes.forEach(this.setNode);
-      }
-    },
-    addPools() {
-      if (!this.collaboration) {
-        return;
-      }
-      this.collaboration.get('participants').forEach(this.setNode);
-    },
-    setUpDiagram() {
-      this.processes.forEach(process => {
-        this.ensureCancelActivityIsAddedToBoundaryEvents(process);
-
-        this.addLanes(process);
-
-        const flowElements = process.get('flowElements');
-        const artifacts = process.get('artifacts');
-
-        this.loadFlowElements(flowElements, artifacts);
-        this.loadSequenceFlows(flowElements, artifacts);
-        this.loadArtifacts(flowElements, artifacts);
-        this.loadAssociations(flowElements, artifacts);
-        this.loadDataAssociations(flowElements);
-      });
-
-      store.commit('setRootElements', this.definitions.rootElements);
-
-      this.addMessageFlows();
-
-      store.commit('highlightNode', this.processNode);
-    },
-    getCollaboration() {
-      return this.definitions.rootElements.find(({ $type }) => $type === 'bpmn:Collaboration');
-    },
-    getProcesses() {
-      return this.definitions.rootElements.filter(({ $type }) => $type === 'bpmn:Process');
-    },
-    getPlane() {
-      return this.definitions.diagrams[0].plane;
-    },
-    getPlaneElements() {
-      return this.plane.get('planeElement');
-    },
-    parse() {
-      this.collaboration = this.getCollaboration();
-      this.processes = this.getProcesses();
-      this.plane = this.getPlane();
-      this.planeElements = this.getPlaneElements();
-
-      this.cleanPlaneElements();
-
-      this.processNode = new Node(
-        'processmaker-modeler-process',
-        this.processes[0],
-        this.planeElements.find(diagram => diagram.bpmnElement.id === this.processes[0].id),
-      );
-    },
-    removeUnsupportedElementAttributes(definition) {
-      const unsupportedElements = ['extensionElements'];
-
-      unsupportedElements.filter(name => definition.get(name))
-        .forEach(name => definition.set(name, undefined));
-    },
-    getCustomParser(definition) {
-      const parsers = this.parsers[(definition.$type)];
-
-      if (!parsers) {
-        return;
-      }
-
-      const customParser = parsers.custom.find(parser => parser(definition, this.moddle));
-      const implementationParser = parsers.implementation.find(parser => parser(definition, this.moddle));
-      const defaultParser = parsers.default.find(parser => parser(definition, this.moddle));
-
-      return customParser || implementationParser || defaultParser;
-    },
-    handleUnsupportedElement(bpmnType, flowElements, definition, artifacts, diagram) {
-      pull(flowElements, definition);
-      pull(artifacts, definition);
-      pull(this.planeElements, diagram);
-      if (this.collaboration) {
-        pull(this.collaboration.get('messageFlows'), definition);
-      }
-
-      const incomingFlows = definition.get('incoming');
-      if (incomingFlows) {
-        pull(flowElements, incomingFlows);
-      }
-
-      const outgoingFlows = definition.get('outgoing');
-      if (outgoingFlows) {
-        pull(flowElements, outgoingFlows);
-      }
-    },
-    setNode(definition, flowElements, artifacts) {
-      const diagram = this.planeElements.find(diagram => diagram.bpmnElement.id === definition.id);
-      const bpmnType = definition.$type;
-      const parser = this.getCustomParser(definition);
-
-      if (!parser) {
-        this.handleUnsupportedElement(bpmnType, flowElements, definition, artifacts, diagram);
-        return;
-      }
-
-      this.removeUnsupportedElementAttributes(definition);
-      const type = parser(definition, this.moddle);
-
-      const unnamedElements = ['bpmn:TextAnnotation', 'bpmn:Association', 'bpmn:DataOutputAssociation', 'bpmn:DataInputAssociation'];
-      const requireName = unnamedElements.indexOf(bpmnType) === -1;
-      if (requireName && !definition.get('name')) {
-        definition.set('name', '');
-      }
-
-      const node = this.createNode(type, definition, diagram);
-
-      store.commit('addNode', node);
-    },
-    createNode(type, definition, diagram) {
-      if (Node.isTimerType(type)) {
-        return new TimerEventNode(type, definition, diagram);
-      }
-      // Remove undefined or null properties
-      Object.keys(definition).forEach(key => {
-        if (definition[key] === undefined || definition[key] === null) {
-          delete definition[key];
-        }
-      });
-      return new Node(type, definition, diagram);
-    },
-    hasSourceAndTarget(definition) {
-      const hasSource = definition.sourceRef && this.parsers[definition.sourceRef.$type];
-      const hasTarget = definition.targetRef && this.parsers[definition.targetRef.$type];
-
-      return hasSource && hasTarget;
-    },
-    async waitForCursorToChange() {
-      const cursorWaitTime = 300;
-      await this.$nextTick();
-      return new Promise(resolve => setTimeout(resolve, cursorWaitTime));
-    },
-    async renderPaper() {
-      this.isRendering = true;
-      await this.paperManager.performAtomicAction(async() => {
-        await this.waitForCursorToChange();
-        this.parse();
-        this.addPools();
-        this.setUpDiagram();
-      });
-      await this.paperManager.awaitScheduledUpdates();
-      this.isRendering = false;
-      this.$emit('parsed');
-    },
-    async loadXML(xml = null) {
-      let emitChangeEvent = false;
-      if (xml === null) {
-        xml = this.currentXML;
-        emitChangeEvent = true;
-      }
-      this.definitions = await this.xmlManager.getDefinitionsFromXml(xml);
-      this.xmlManager.definitions = this.definitions;
-      this.nodeIdGenerator = getNodeIdGenerator(this.definitions);
-      store.commit('clearNodes');
-      await this.renderPaper();
-      if (emitChangeEvent) {
-        window.ProcessMaker.EventBus.$emit('modeler-change');
-      }
-    },
-    getBoundaryEvents(process) {
-      return process.get('flowElements').filter(({ $type }) => $type === 'bpmn:BoundaryEvent');
-    },
-    createBoundaryEvent(definition) {
-      const boundaryEvent = boundaryEventConfig.definition(this.moddle, this.$t);
-      boundaryEvent.set('id', definition.get('id'));
-      boundaryEvent.set('name', definition.get('name'));
-      boundaryEvent.set('eventDefinitions', definition.get('eventDefinitions'));
-      boundaryEvent.set('cancelActivity', definition.get('cancelActivity'));
-      boundaryEvent.set('attachedToRef', definition.get('attachedToRef'));
-      boundaryEvent.set('color', definition.get('color'));
-      boundaryEvent.$parent = definition.$parent;
-      if (definition.get('outgoing').length > 0) {
-        boundaryEvent.set('outgoing', definition.get('outgoing'));
-      }
-      return boundaryEvent;
-    },
-    ensureCancelActivityIsAddedToBoundaryEvents(process) {
-      this.getBoundaryEvents(process).forEach(definition => {
-        const boundaryEvent = this.createBoundaryEvent(definition);
-        definition.get('outgoing').forEach(outgoing => outgoing.set('sourceRef', boundaryEvent));
-        this.replaceDefinition(definition, boundaryEvent, process);
-      });
-    },
-    replaceDefinition(definition, boundaryEvent, process) {
-      const definitionIndex = process.get('flowElements').indexOf(definition);
-      process.flowElements[definitionIndex] = boundaryEvent;
-      const boundaryEventDiagram = this.planeElements.find((diagram) => {
-        return diagram.bpmnElement === definition;
-      });
-      boundaryEventDiagram.bpmnElement = boundaryEvent;
-    },
-    toXML(cb) {
-      this.moddle.toXML(this.definitions, { format: true }, cb);
-    },
-    async handleDrop({ clientX, clientY, control, nodeThatWillBeReplaced }) {
-      this.validateDropTarget({ clientX, clientY, control });
-
-      if (!this.allowDrop) {
-        return;
-      }
-
-      const definition = this.nodeRegistry[control.type].definition(this.moddle, this.$t);
-
-      const diagram = this.nodeRegistry[control.type].diagram(this.moddle);
-
-      const { x, y } = this.paperManager.clientToGridPoint(clientX, clientY);
-      diagram.bounds.x = x;
-      diagram.bounds.y = y;
-
-      const newNode = this.createNode(control.type, definition, diagram);
-
-      if (newNode.isBpmnType('bpmn:BoundaryEvent')) {
-        this.setShapeCenterUnderCursor(diagram);
-      }
-
-      this.highlightNode(newNode);
-      await this.addNode(newNode);
-      if (!nodeThatWillBeReplaced) {
-        return;
-      }
-
-      const nodeMigrator = new NodeMigrator(
-        nodeThatWillBeReplaced,
-        definition,
-        this.graph,
-        newNode,
-        this.processes,
-        this.collaboration,
-      );
-      nodeMigrator.migrate();
-
-      return newNode;
-    },
-    setShapeCenterUnderCursor(diagram) {
-      diagram.bounds.x -= (diagram.bounds.width / 2);
-      diagram.bounds.y -= (diagram.bounds.height / 2);
-    },
-    async selectNewNode(node) {
-      await this.$nextTick();
-      await this.paperManager.awaitScheduledUpdates();
-      const newNodeComponent = this.$refs.nodeComponent.find(component => component.node === node);
-      const view = newNodeComponent.shapeView;
-      await this.$refs.selector.selectElement(view);
-    },
-    async addNode(node) {
-      if (!node.pool) {
-        node.pool = this.poolTarget;
-      }
-
-      const targetProcess = node.getTargetProcess(this.processes, this.processNode);
-      addNodeToProcess(node, targetProcess);
-      node.setIds(this.nodeIdGenerator);
-
-      this.planeElements.push(node.diagram);
-      store.commit('addNode', node);
-      this.poolTarget = null;
-
-      // add processmaker-modeler-generic-flow
-      if ([
-        sequenceFlowId,
-        laneId,
-        associationId,
-        messageFlowId,
-        dataOutputAssociationFlowId,
-        dataInputAssociationFlowId,
-        genericFlowId,
-      ].includes(node.type)) {
-        return;
-      }
-
-      // Select the node after it has been added to the store (does not apply to flows)
-      this.selectNewNode(node);
-    },
-    async addClonedNodes(nodes) {
-      nodes.forEach(node => {
-        if (!node.pool) {
-          node.pool = this.poolTarget;
-        }
-
-        const targetProcess = node.getTargetProcess(this.processes, this.processNode);
-        addNodeToProcess(node, targetProcess);
-
-        this.planeElements.push(node.diagram);
-        store.commit('addNode', node);
-        this.poolTarget = null;
-      });
-    },
-    handleResize() {
-      const { clientWidth, clientHeight } = this.$el.parentElement;
-      this.parentWidth = clientWidth + 'px';
-      this.parentHeight = clientHeight + 'px';
-
-      this.paperManager.setPaperDimensions(clientWidth, clientHeight);
-    },
-    validateDropTarget({ clientX, clientY, control }) {
-      const { allowDrop, poolTarget } = getValidationProperties(clientX, clientY, control, this.paperManager.paper, this.graph, this.collaboration, this.$refs['paper-container']);
-      this.allowDrop = allowDrop;
-      this.poolTarget = poolTarget;
-    },
-    isBpmnNode(shape) {
-      return shape.component != null;
-    },
-    setShapeStacking(shape) {
-      if (this.isRendering || (!shape.component.node.isType('processmaker-modeler-pool') && shape === this.previouslyStackedShape)) {
-        return;
-      }
-
-      this.previouslyStackedShape = shape;
-      this.paperManager.performAtomicAction(() => ensureShapeIsNotCovered(shape, this.graph));
-    },
-    clearSelection(){
-      this.$refs.selector.clearSelection();
-    },
-    isPointInSelection(event) {
-      const selector = this.$refs.selector.$el;
-      if (typeof selector.getBoundingClientRect === 'function') {
-        // check if mouse was clicked inside the selector
-        const { x: sx, y: sy, width:swidth, height: sheight } = selector.getBoundingClientRect();
-        if (event.clientX >= sx && event.clientX <= sx + swidth && event.clientY >= sy && event.clientY <= sy + sheight) {
-          return true;
-        }
-      }
-      return false;
-    },
-    async pointerDownInShape(event, element) {
-      const { clientX: x, clientY: y } = event;
-      const shapeView = this.paper.findViewByModel(element);
-      this.isDragging = false;
-      this.isSelecting = false;
-      this.isIntoTheSelection = false;
-      this.dragStart = { x, y };
-      // Verify if is in the selection box
-      if (this.isPointInSelection(event)) {
-        this.isIntoTheSelection = true;
-      } else {
-        if (!event.shiftKey) {
-          await this.$refs.selector.selectElement(shapeView);
-          await this.$nextTick();
-        }
-      }
-      this.$refs.selector.startDrag({
-        clientX: event.clientX,
-        clientY: event.clientY,
-      });
-    },
-    pointerUpHandler(event, cellView) {
-      // is clicked over the shape
-      if (cellView) {
-        this.$refs.selector.selectElement(cellView);
-      } else {
-        this.clearSelection();
-      }
-
-      this.isDragging = false;
-      this.dragStart = null;
-      this.isSelecting = false;
-    },
-  },
-  created() {
-    if (runningInCypressTest()) {
-      /* Add reference to store on window; this is used in testing to verify rendered nodes */
-      window.store = store;
-    }
-
-    this.$t = this.$t.bind(this);
-    /**
-     * Before Initialize the BpmnModdle and its extensions.
-     * In this stage the node components were not yet registered,
-     * so they could be extended.
-     */
-    window.ProcessMaker.EventBus.$emit('modeler-before-init', {
-      registerComponentMixin: this.registerComponentMixin,
-    });
-
-    this.registerNode(Process);
-    /* Initialize the BpmnModdle and its extensions */
-    window.ProcessMaker.EventBus.$emit('modeler-init', {
-      registerInspectorExtension,
-      registerBpmnExtension: this.registerBpmnExtension,
-      registerNode: this.registerNode,
-      registerStatusBar: this.registerStatusBar,
-    });
-
-    this.moddle = new BpmnModdle(this.extensions);
-    this.linter = new Linter(linterConfig);
-    this.xmlManager = new XMLManager(this.moddle);
-    this.$emit('set-xml-manager', this.xmlManager);
-  },
-  mounted() {
-    store.commit('setReadOnly', this.readOnly);
-
-    this.graph = new dia.Graph();
-    store.commit('setGraph', this.graph);
-    this.graph.set('interactiveFunc', cellView => {
-      const isPoolEdge = cellView.model.get('type') === 'standard.EmbeddedImage';
-      return {
-        elementMove: isPoolEdge,
-        labelMove: false,
-      };
-    });
-
-    this.paperManager = PaperManager.factory(this.$refs.paper, this.graph.get('interactiveFunc'), this.graph);
-    this.paper = this.paperManager.paper;
-
-    this.paperManager.addEventHandler('cell:pointerdblclick', focusNameInputAndHighlightLabel);
-
-    this.handleResize();
-    window.addEventListener('resize', this.handleResize);
-
-    store.commit('setPaper', this.paperManager.paper);
-
-    this.paperManager.addEventHandler('element:pointerclick', this.blurFocusedScreenBuilderElement, this);
-
-    this.paperManager.addEventHandler('blank:pointerdown', (event, x, y) => {
-      const scale = this.paperManager.scale;
-      this.canvasDragPosition = { x: x * scale.sx, y: y * scale.sy };
-      this.isGrabbing = true;
-    }, this);
-
-    this.paperManager.addEventHandler('cell:mouseover element:mouseover', ({ model: shape }) => {
-      if (this.isBpmnNode(shape) && shape.attr('body/cursor') !== 'default' && !this.isGrabbing) {
-        shape.attr('body/cursor', 'move');
-      }
-      // If the user is panning the Paper while hovering an element, ignore the default move cursor
-      if (this.isGrabbing && this.isBpmnNode(shape)) {
-        shape.attr('body/cursor', 'grabbing');
-      }
-    });
-    this.paperManager.addEventHandler('blank:pointerup', (event) => {
-      this.canvasDragPosition = null;
-      this.isGrabbing = false;
-      this.activeNode = null;
-      this.pointerUpHandler(event);
-    }, this);
-
-    this.paperManager.addEventHandler('cell:pointerup', (cellView, event) => {
-      this.canvasDragPosition = null;
-      this.activeNode = null;
-      this.pointerUpHandler(event, cellView);
-    }, this);
-
-    this.$el.addEventListener('mousemove', event => {
-      if (this.canvasDragPosition) {
-        this.paperManager.translate(
-          event.offsetX - this.canvasDragPosition.x,
-          event.offsetY - this.canvasDragPosition.y,
-        );
-      }
-    }, this);
-
-    this.$el.addEventListener('mouseenter', () => {
-      store.commit('setClientLeftPaper', false);
-    });
-
-    this.$el.addEventListener('mouseleave', () => {
-      this.paperManager.removeEventHandler('blank:pointermove');
-      store.commit('setClientLeftPaper', true);
-    });
-
-    this.paperManager.addEventHandler('cell:pointerclick', (cellView, evt, x, y) => {
-      const clickHandler = cellView.model.get('onClick');
-      if (clickHandler) {
-        clickHandler(cellView, evt, x, y);
-      }
-    });
-
-    this.paperManager.addEventHandler('cell:pointerclick', ({ model: shape }, event) => {
-      if (!this.isBpmnNode(shape)) {
-        return;
-      }
-
-      // ignore click event if the user is grabbing the paper.
-      if (this.isGrabbing) {
-        return;
-      }
-
-      shape.component.$emit('click', event);
-      this.$emit('click', {
-        event,
-        node: this.highlightedNode.definition,
-      });
-    });
-
-    this.paperManager.addEventHandler('cell:pointerdown', ({ model: shape }, event) => {
-      if (!this.isBpmnNode(shape)) {
-        return;
-      }
-      // If the user is pressing Space (grabbing) and clicking on a Cell, return
-      if (this.isGrabbing) {
-        return;
-      }
-      this.setShapeStacking(shape);
-      this.activeNode = shape.component.node;
-      this.isOverShape = true;
-      this.pointerDownInShape(event, shape);
-    });
-    // If the user is grabbing the paper while he clicked in a cell, move the paper and not the cell
-    this.paperManager.addEventHandler('cell:pointermove', (_, event, x, y) => {
-      if (this.isGrabbing) {
-        if (!this.canvasDragPosition) {
-          const scale = this.paperManager.scale;
-          this.canvasDragPosition = { x: x * scale.sx, y: y * scale.sy };
-        }
-        if (this.canvasDragPosition && !this.clientLeftPaper) {
-          this.paperManager.translate(
-            event.offsetX - this.canvasDragPosition.x,
-            event.offsetY - this.canvasDragPosition.y
-          );
-        }
-      }
-    });
-
-    /* Register custom nodes */
-    window.ProcessMaker.EventBus.$emit('modeler-start', {
-      loadXML: async(xml) => {
-        await this.loadXML(xml);
-      },
-    });
-  },
-};
-</script>
-<style lang="scss" src="./modeler.scss" />
-<style lang="scss">
-svg {
-  overflow: visible !important;
-}
-
-.rail {
-  &-container {
-    position: relative;
-    bottom: 60px;
-    display: inline-block;
-    height: 48px;
-    max-height: 48px;
-    z-index: 2;
-  }
-
-  &-left {
-    position: absolute;
-    display: inline;
-    width: auto;
-    padding: 0 12px;
-  }
-}
-</style>