у меня есть вот такой код 
import { IPoint } from '../models/infrastucture/point';
import Konva from 'konva';
import { ConnectorTypes } from '../models/primitives/enums/connector-types';
import { LineTypes } from './lineTypes';

/**
 * Рассчитывает точки для построения связи между двумя коннекторами
 *
 * @param fromAbsolute Абсолютная позиция источника.
 * @param toAbsolute Абсолютная позиция назначения.
 * @param fromId — id начального объекта
 * @param toId — id конечного объекта
 * @param scale — масштабирование
 * @param stagePoint — точка позиционирования канвы
 * @param obstacles — массив препятствий
 * @param type
 * @returns Массив чисел, представляющих точки линии.
 */
export const calculateLinePoints = (
  fromAbsolute: IPoint,
  toAbsolute: IPoint,
  fromId: string | number,
  toId: string | number,
  scale: number,
  stagePoint: IPoint,
  obstacles: Array<{ x: number; y: number; width: number; height: number; id: string | number }>,
  type?: LineTypes,
): number[] => {
  const sourceConnector = { x: (fromAbsolute.x - stagePoint.x) / scale, y: (fromAbsolute.y - stagePoint.y) / scale };
  const targetConnector = { x: (toAbsolute.x - stagePoint.x) / scale, y: (toAbsolute.y - stagePoint.y) / scale };

  const sourceObject = obstacles.find((x) => x.id === fromId);
  const targetObject = obstacles.find((x) => x.id === toId);
  if (!sourceObject || !targetObject) {
    return [];
  }
  const points: number[] = [];
  const shift = 6;

  // Если коннекторы смотрят в разные стороны
  if (
    (sourceObject.x < sourceConnector.x && Math.abs(targetObject.x - targetConnector.x) < 25) ||
    (Math.abs(sourceConnector.x - sourceObject.x) < 25 && targetObject.x < targetConnector.x)
  ) {
    //Если они друг напротив друга
    if (
      (sourceObject.x < sourceConnector.x &&
        sourceConnector.x < targetConnector.x &&
        targetConnector.x < targetObject.x) ||
      (targetObject.x < targetConnector.x &&
        targetConnector.x < sourceConnector.x &&
        sourceConnector.x < sourceObject.x)
    ) {
      // Если объекты на одном уровне (связь — прямая линия)
      if (sourceConnector.y === targetConnector.y) {
        if (type) {
          type = LineTypes.Straight;
        }
        return [sourceConnector.x, sourceConnector.y, targetConnector.x, targetConnector.y];
      }
    }
    // Если примитивы "спиной" друг к другу
    else {
      // Если объекты на одном уровне
      // Если объекты на разных уровнях, но по вертикали между ними нет свободного расстояния
      // Связь — скобка
      if (
        sourceConnector.y === targetConnector.y ||
        (sourceObject.y + sourceObject.height >= targetObject.y &&
          sourceObject.y + sourceObject.height <= targetObject.y + targetObject.height) ||
        (targetObject.y + targetObject.height >= sourceObject.y &&
          targetObject.y + targetObject.height <= sourceObject.y + sourceObject.height)
      ) {
        // Начальная точка
        points.push(sourceConnector.x, sourceConnector.y);

        // Вертикальная линия выше наивысшего или ниже нижайшего из двух примитивов
        const secondPoint = {
          x: sourceConnector.x,
          y:
            Math.min(sourceObject.y, targetObject.y) > shift
              ? Math.min(sourceObject.y, targetObject.y) - shift
              : Math.max(sourceObject.y + sourceObject.height, targetObject.y + targetObject.height) + shift,
        };
        points.push(secondPoint.x, secondPoint.y);

        // Горизонтальный отрезок
        const thirdPoint = { x: targetConnector.x, y: secondPoint.y };
        points.push(thirdPoint.x, thirdPoint.y);

        // Конечная точка
        points.push(targetConnector.x, targetConnector.y);

        if (type) {
          type = sourceConnector.y < secondPoint.y ? LineTypes.BottomBracket : LineTypes.TopBracket;
        }
        return points;
      }
    }

    // Если между объектами есть расстояние (связь из трех отрезков)
    if (
      (sourceObject.x < sourceConnector.x &&
        sourceConnector.x < targetConnector.x &&
        targetConnector.x < targetObject.x) ||
      (targetObject.x < targetConnector.x &&
        targetConnector.x < sourceConnector.x &&
        sourceConnector.x < sourceObject.x)
    ) {
      // Начальная точка
      points.push(sourceConnector.x, sourceConnector.y);

      // Горизонтальный сегмент до средней точки по X
      const midX = (sourceConnector.x + targetConnector.x) / 2;
      points.push(midX, sourceConnector.y);

      // Вертикальный сегмент до уровня второго коннектора
      points.push(midX, targetConnector.y);

      // Горизонтальный сегмент до второго коннектора
      points.push(targetConnector.x, targetConnector.y);

      if (type) {
        type = LineTypes.ThreeSegments;
      }
      return points;
    }

    // Если объекты расположены внахлест (связь из 5 отрезков)
    if (
      (sourceObject.x < sourceConnector.x &&
        sourceConnector.x > targetConnector.x &&
        targetConnector.x < targetObject.x) ||
      (targetObject.x < targetConnector.x &&
        targetConnector.x > sourceConnector.x &&
        sourceConnector.x < sourceObject.x)
    ) {
      // Начальная точка
      points.push(sourceConnector.x, sourceConnector.y);

      // Первый горизонтальный сегмент, продлевающий коннектор
      const secondPoint = {
        x: sourceConnector.x + (sourceObject.x < sourceConnector.x ? shift : -shift),
        y: sourceConnector.y,
      };
      points.push(secondPoint.x, secondPoint.y);

      // Вертикальный сегмент до середины расстояния между примитивами
      const thirdPoint = {
        x: secondPoint.x,
        y:
          targetConnector.y > sourceConnector.y
            ? (targetConnector.y - sourceConnector.y) / 2 + sourceConnector.y
            : (sourceConnector.y - targetConnector.y) / 2 + targetConnector.y,
      };
      points.push(thirdPoint.x, thirdPoint.y);

      // Центральный горизонтальный сегмент
      const fourthPoint = {
        x: targetConnector.x + (targetConnector.x < targetObject.x ? -shift : shift),
        y: thirdPoint.y,
      };
      points.push(fourthPoint.x, fourthPoint.y);

      // Вертикальный сегмент до уровня конечного коннектора
      const fifthPoint = { x: fourthPoint.x, y: targetConnector.y };
      points.push(fifthPoint.x, fifthPoint.y);

      // Горизонтальный сегмент до конечного коннектора
      points.push(targetConnector.x, targetConnector.y);

      if (type) {
        type = LineTypes.Overlapping;
      }
      return points;
    }
  }

  // Если коннекторы направлены в одну сторону
  else {
    // Если объекты расположены на одном уровне
    if (
      (sourceConnector.y > targetObject.y && sourceConnector.y < targetObject.y + targetObject.height) ||
      (targetConnector.y > sourceObject.y && targetConnector.y < sourceObject.y + sourceObject.height)
    ) {
      // Начальная точка
      points.push(sourceConnector.x, sourceConnector.y);

      // Вертикальная линия выше наивысшего или ниже нижайшего из двух примитивов
      const secondPoint = {
        x: sourceConnector.x,
        y:
          Math.min(sourceObject.y, targetObject.y) > shift
            ? Math.min(sourceObject.y, targetObject.y) + shift
            : Math.max(sourceObject.y + sourceObject.height, targetObject.y + targetObject.height) - shift,
      };
      points.push(secondPoint.x, secondPoint.y);

      // Горизонтальный отрезок
      const thirdPoint = { x: targetConnector.x, y: secondPoint.y };
      points.push(thirdPoint.x, thirdPoint.y);

      // Конечная точка
      points.push(targetConnector.x, targetConnector.y);

      return points;
    }

    // Если объекты расположены на разном уровне
    else {
      // Начальная точка
      points.push(sourceConnector.x, sourceConnector.y);

      // Горизонтальная линия длиной до целевого коннектора
      const secondPoint = {
        x:
          sourceConnector.x < sourceObject.x
            ? Math.min(sourceConnector.x, targetConnector.x)
            : Math.max(sourceConnector.x, targetConnector.x),
        y: sourceConnector.y,
      };

      // Вертикальная линия до целевого коннектора
      points.push(secondPoint.x, secondPoint.y);

      // Горизонтальная линия до конечной точки
      points.push(targetConnector.x, targetConnector.y);

      return points;
    }
  }
  return [sourceConnector.x, sourceConnector.y, targetConnector.x, targetConnector.y];
};

/**
 * Рассчитывает точки для превью связи, не доведенной до конечного коннектора
 * @param connectorPositionAbsolute — абсолютная координата стартового коннектора
 * @param connectorType — тип стартового коннектора
 * @param pointerPositionAbsolute — абсолютная координата указателя мыши на сцене
 * @param scale — масштабирование
 * @param stagePoint — точка позиционирования канвы
 */
export const calculatePreviewLinePoints = (
  connectorPositionAbsolute: IPoint,
  connectorType: ConnectorTypes,
  pointerPositionAbsolute: IPoint,
  scale: number,
  stagePoint: IPoint,
): number[] => {
  const connectorPosition = {
    x: (connectorPositionAbsolute.x - stagePoint.x) / scale,
    y: (connectorPositionAbsolute.y - stagePoint.y) / scale,
  };
  const pointerPosition = {
    x: (pointerPositionAbsolute.x - stagePoint.x) / scale,
    y: (pointerPositionAbsolute.y - stagePoint.y) / scale,
  };
  const points: number[] = [];

  points.push(connectorPosition.x, connectorPosition.y);
  if (
    (connectorType === ConnectorTypes.Output && pointerPosition.x >= connectorPosition.x) ||
    (connectorType === ConnectorTypes.Input && pointerPosition.x <= connectorPosition.x)
  ) {
    const secondPoint = { x: (connectorPosition.x + pointerPosition.x) / 2, y: connectorPosition.y };
    points.push(secondPoint.x, secondPoint.y);

    const thirdPoint = { x: secondPoint.x, y: pointerPosition.y };
    points.push(thirdPoint.x, thirdPoint.y);

    points.push(pointerPosition.x, pointerPosition.y);
  } else {
    const secondPoint = {
      x: connectorPosition.x,
      y:
        pointerPosition.y > connectorPosition.y
          ? (pointerPosition.y - connectorPosition.y) / 2 + connectorPosition.y
          : (connectorPosition.y - pointerPosition.y) / 2 + pointerPosition.y,
    };
    points.push(secondPoint.x, secondPoint.y);

    const thirdPoint = {
      x: pointerPosition.x,
      y: secondPoint.y,
    };
    points.push(thirdPoint.x, thirdPoint.y);

    points.push(pointerPosition.x, pointerPosition.y);
  }
  return points;
};

/**
 * Ищет Id примитива, которому принадлежит коннектор
 * @param node
 * @param parentId
 * @param connectorId
 */
export const findParentPrimitiveOfConnector = (
  node: Konva.Shape | Konva.Group,
  parentId: string | number,
  connectorId: string | number,
): { x: number; y: number; id: string | number } | null => {
  if (node.id() === `connector-${connectorId}`) {
    const position = node.getAbsolutePosition();
    return { x: position.x, y: position.y, id: parentId };
  }

  if ('children' in node) {
    for (const child of node.getChildren()) {
      const foundId = findParentPrimitiveOfConnector(child, parentId, connectorId);
      if (foundId) {
        return foundId;
      }
    }
  }
  return null;
};


сейчас тут тип линии возвращается плохо -- я подаю перменную в аргументы и меняю его внутри функции 
но я бы хотела возвращать тип вместе с массивом. чтобы мне возвращалось иногда два значения массив и тип а иногда одно только -- массив 
при этом у меня реализовано много кода. если я верну numbers[] | {points: numbers[], type: LineType} мне придется так много менять на доступ к этим самым тайп, а мне так не хочется переписывать все вызовы