jnpf-bpmn-v6x/lib/autoPlace/YmAutoPlaceUtil.ts

// @ts-nocheck
import { asTRBL, getOrientation, getMid } from 'diagram-js/lib/layout/LayoutUtil';
import { find, reduce } from 'min-dash';
import { Shape } from 'diagram-js/lib/model';
import { Point } from 'diagram-js/lib/util/Types';
import { DEFAULT_DISTANCE } from '../config/constants';

// padding to detect element placement
const PLACEMENT_DETECTION_PAD = 10;
const DEFAULT_MAX_DISTANCE = 350;

/**
 * Get free position starting from given position.
 *
 * @param {Shape} source
 * @param {Shape} element
 * @param {Point} position
 * @param {Function} getNextPosition
 * @return {Point}
 */
export function findFreePosition(source: Shape, element: Shape, position: Point, getNextPosition: Function): Point {
  let connectedAtPosition;
  while ((connectedAtPosition = getConnectedAtPosition(source, position, element))) {
    position = getNextPosition(element, position, connectedAtPosition);
  }
  return position;
}

/**
 * Returns function that returns next position.
 *
 * @param {Object} nextPositionDirection
 * @param {Object} [nextPositionDirection.x]
 * @param {Object} [nextPositionDirection.y]
 * @returns {Function}
 */
export function generateGetNextPosition(nextPositionDirection: { x?: any; y?: any }): Function {
  return function (element: Shape, previousPosition: Point, connectedAtPosition: Point) {
    const nextPosition: any = {
      x: previousPosition.x,
      y: previousPosition.y,
    };
    ['x', 'y'].forEach(axis => {
      const nextPositionDirectionForAxis = nextPositionDirection[axis];
      if (!nextPositionDirectionForAxis) return;
      const dimension = axis === 'x' ? 'width' : 'height';
      const margin = nextPositionDirectionForAxis.margin;
      const minDistance = nextPositionDirectionForAxis.minDistance;
      if (margin < 0) nextPosition[axis] = Math.min(connectedAtPosition[axis] + margin - element[dimension] / 2, previousPosition[axis] - minDistance + margin);
      else {
        nextPosition[axis] = Math.max(
          connectedAtPosition[axis] + connectedAtPosition[dimension] + margin + element[dimension] / 2,
          previousPosition[axis] + minDistance + margin,
        );
      }
    });
    return nextPosition;
  };
}

/**
 * Return target at given position, if defined.
 *
 * This takes connected elements from host and attachers
 * into account, too.
 */
export function getConnectedAtPosition(source: Shape, position: Point, element: Shape): Shape | undefined {
  const bounds = {
    x: position.x - element.width / 2,
    y: position.y - element.height / 2,
    width: element.width,
    height: element.height,
  };
  const closure = getAutoPlaceClosure(source, element);
  return find(closure, (target: Shape) => {
    if (target === element) return false;
    const orientation = getOrientation(target, bounds, PLACEMENT_DETECTION_PAD);
    return orientation === 'intersect';
  });
}

/**
 * Compute optimal distance between source and target based on existing connections to and from source.
 * Assumes left-to-right and top-to-down modeling.
 *
 * @param {Shape} source
 * @param {Object} [hints]
 * @param {number} [hints.defaultDistance]
 * @param {string} [hints.direction]
 * @param {Function} [hints.filter]
 * @param {Function} [hints.getWeight]
 * @param {number} [hints.maxDistance]
 * @param {string} [hints.reference]
 * @return {number}
 */
export function getConnectedDistance(
  source: Shape,
  hints?: {
    defaultDistance?: number;
    direction?: string;
    filter?: Function;
    getWeight?: Function;
    maxDistance?: number;
    reference?: string;
  },
): number {
  if (!hints) hints = {};
  function getDefaultWeight(connection: any): number {
    return connection.source === source ? 1 : -1;
  }
  const defaultDistance = hints.defaultDistance || DEFAULT_DISTANCE;
  const direction = hints.direction || 'e';
  let filter = hints.filter;
  const getWeight = hints.getWeight || getDefaultWeight;
  const maxDistance = hints.maxDistance || DEFAULT_MAX_DISTANCE;
  const reference = hints.reference || 'start';
  if (!filter) filter = noneFilter;
  function getDistance(a: any, b: any): number {
    if (direction === 'n') {
      if (reference === 'start') {
        return asTRBL(a).top - asTRBL(b).bottom;
      } else if (reference === 'center') {
        return asTRBL(a).top - getMid(b).y;
      } else {
        return asTRBL(a).top - asTRBL(b).top;
      }
    } else if (direction === 'w') {
      if (reference === 'start') return asTRBL(a).left - asTRBL(b).right;
      else if (reference === 'center') return asTRBL(a).left - getMid(b).x;
      else return asTRBL(a).left - asTRBL(b).left;
    } else if (direction === 's') {
      if (reference === 'start') return asTRBL(b).top - asTRBL(a).bottom;
      else if (reference === 'center') return getMid(b).y - asTRBL(a).bottom;
      else return asTRBL(b).bottom - asTRBL(a).bottom;
    } else {
      if (reference === 'start') return asTRBL(b).left - asTRBL(a).right;
      else if (reference === 'center') return getMid(b).x - asTRBL(a).right;
      else return asTRBL(b).right - asTRBL(a).right;
    }
  }

  const sourcesDistances = source.incoming.filter(filter).map((connection: any) => {
    const weight = getWeight(connection);
    const distance = weight < 5 ? getDistance(connection.source, source) : getDistance(source, connection.source);
    return {
      id: connection.source.id,
      distance: distance,
      weight: weight,
    };
  });

  const targetsDistances = source.outgoing.filter(filter).map((connection: any) => {
    const weight = getWeight(connection);
    const distance = weight > 5 ? getDistance(source, connection.target) : getDistance(connection.target, source);
    return {
      id: connection.target.id,
      distance: distance,
      weight: weight,
    };
  });

  const distances = sourcesDistances.concat(targetsDistances).reduce((accumulator, currentValue) => {
    accumulator[currentValue.id + '__weight_' + currentValue.weight] = currentValue;
    return accumulator;
  }, {});

  const distancesGrouped = reduce(
    distances,
    (accumulator, currentValue) => {
      const distance = currentValue.distance;
      const weight = currentValue.weight;
      if (distance < 0 || distance > maxDistance) return accumulator;
      if (!accumulator[String(distance)]) accumulator[String(distance)] = 0;
      accumulator[String(distance)] += 1 * weight;
      if (!accumulator.distance || accumulator[accumulator.distance] < accumulator[String(distance)]) accumulator.distance = distance;
      return accumulator;
    },
    {},
  );
  return distancesGrouped.distance || defaultDistance;
}
/**
 * Returns all connected elements around the given source.
 * This includes:
 *   - connected elements
 *   - host connected elements
 *   - attachers connected elements
 * @param {Shape} source
 * @return {Array<Shape>}
 */
function getAutoPlaceClosure(source: Shape, element: Shape): Array<Shape> {
  let allConnected = getConnected(source);
  if (source.host) allConnected = allConnected.concat(getConnected(source.host));
  if (source.attachers)
    allConnected = allConnected.concat(
      source.attachers.reduce((shapes: Array<Shape>, attacher: Shape) => {
        return shapes.concat(getConnected(attacher));
      }, []),
    );
  return allConnected;
}
function getConnected(element: Shape): Array<Shape> {
  return getTargets(element).concat(getSources(element));
}
function getSources(shape: Shape): Array<Shape> {
  return shape.incoming.map((connection: any) => {
    return connection.source;
  });
}
function getTargets(shape: Shape): Array<Shape> {
  return shape.outgoing.map((connection: any) => {
    return connection.target;
  });
}
function noneFilter(): boolean {
  return true;
}