if (!GetAntennaPlace( ...

Ниже приведён пример того, как можно переписать исходный C#-код на JavaScript, сохранив ту же логику. В примере предполагается, что у вас есть функции/объекты, аналогичные C#-методам (GetAntennaPlace, mineManager.NodeManager.TryGetNodeModelById и т.д.). Вместо out в C# для передачи значений можно возвращать объект с нужными полями:

js
function addAntenna(data, deviceModel, mineManager, logger) {
  // Предположим, что GetAntennaPlace возвращает объект, где:
  //   success: boolean — удалось или нет
  //   antennaPlace: вычисленное значение
  //   antennaDirectionPlace: вычисленное значение
  const getAntennaResult = GetAntennaPlace(
    data.NodeId,
    data.DirectionNodeId,
    data.OffsetDirectionNodeId,
    data.Offset != null ? data.Offset : 0,
    deviceModel
  );

  if (!getAntennaResult.success) {
    logger.error("AddAntenna: Не удалось вычислить положение антенны");
    return false;
  }

  const antennaPlace = getAntennaResult.antennaPlace;
  const antennaDirectionPlace = getAntennaResult.antennaDirectionPlace;

  // Предположим, что TryGetNodeModelById возвращает объект вида:
  //   { success: boolean, nodeModel: <модель узла> }
  let nodeModelResult = mineManager.NodeManager.TryGetNodeModelById(data.NodeId);
  if (!nodeModelResult.success) {
    logger.error(`AddAntenna: Не удалось найти узел установки с Id '${data.NodeId}' антенны`);
    return false;
  }
  const nodeModel = nodeModelResult.nodeModel;

  let directionNodeResult = mineManager.NodeManager.TryGetNodeModelById(data.DirectionNodeId);
  if (!directionNodeResult.success) {
    logger.error(`AddAntenna: Не удалось найти узел направления с Id '${data.DirectionNodeId}' антенны`);
    return false;
  }
  const nodeDirectionModel = directionNodeResult.nodeModel;

  // Допустим, что AntennaModel — это "класс" (или функция-конструктор) в JavaScript
  const antennaModel = new AntennaModel(nodeModel, data.GuidAntenna, deviceModel);
  antennaModel.Number = data.Number;
  antennaModel.Position = antennaPlace;
  antennaModel.DirectionNode = nodeDirectionModel;

  if (data.Offset != null && data.Offset > 0) {
    antennaModel.Offset = data.Offset;
  }

  if (data.OffsetDirectionNodeId != null) {
    let offsetNodeResult = mineManager.NodeManager.TryGetNodeModelById(data.OffsetDirectionNodeId);
    if (!offsetNodeResult.success) {
      logger.error(
        `AddAntenna: Не удалось найти узел направления смещения с Id '${data.OffsetDirectionNodeId}' антенны`
      );
      return false;
    }
    antennaModel.OffsetDirectionNode = offsetNodeResult.nodeModel;
  }

  // Если нужно что-то вернуть
  return true;
}

Основные изменения по сравнению с C#:

1. out-параметры. В JavaScript нет out var, поэтому обычно возвращают объект, содержащий все необходимые данные (например, { success, antennaPlace, antennaDirectionPlace }).
2. Проверка null. В C# есть data.Offset.HasValue ? data.Offset.Value : 0; в JavaScript часто используют data.Offset != null ? data.Offset : 0 или оператор ??.
3. Логирование. Вместо _logger.WriteLine(...) можно использовать logger.error(...) или console.error(...).
4. Объявления переменных. Используются const/let вместо C#-переменных.

Остальное — это просто эквивалентная реализация тех же проверок и логики, что и в оригинальном C#-коде.

Ниже приведена «прямая» версия метода GetAntennaPlace на JavaScript.
Я придерживался тех же проверок и сообщений об ошибках, но вместо out‑параметров функция просто возвращает объект‑результат.

js
/**
 * Рассчитать положение антенны и точку, куда она «смотрит».
 *
 * @param {number} nodeId                      – ID узла установки антенны
 * @param {number} directionNodeId            – ID узла‑ориентира (куда смотрит антенна без смещения)
 * @param {?number} offsetDirectionNodeId     – ID узла‑ориентира для смещения (null / undefined, если нет)
 * @param {number} offset                     – величина смещения (метры)
 * @param {Object} deviceModel                – модель устройства (не используется, но оставлена для совместимости)
 * @param {Object} mineManager                – «шахта» со всеми менеджерами
 * @param {Object} logger                     – объект логирования (logger.error / logger.info)
 *
 * @returns {{
 *   success: boolean,
 *   antennaPlace: Vector3|null,
 *   antennaDirectionPlace: Vector3|null
 * }}
 */
function getAntennaPlace(
  nodeId,
  directionNodeId,
  offsetDirectionNodeId,
  offset,
  deviceModel,
  mineManager,
  logger
) {
  let antennaPlace = null;
  let antennaDirectionPlace = null;

  /* --- 1. Узел‑ориентир --- */
  const dirNodeRes = mineManager.NodeManager.TryGetNodeModelById(directionNodeId);
  if (!dirNodeRes.success) {
    logger.error(
      `GetAntennaPlace: Не удалось найти узел направления антенны с Id '${directionNodeId}'`
    );
    return { success: false, antennaPlace, antennaDirectionPlace };
  }
  const directionNode = dirNodeRes.nodeModel;

  /* --- 2. Узел установки --- */
  const nodeRes = mineManager.NodeManager.TryGetNodeModelById(nodeId);
  if (!nodeRes.success) {
    logger.error(
      `GetAntennaPlace: Не удалось найти узел установки антенны с Id '${nodeId}'`
    );
    return { success: false, antennaPlace, antennaDirectionPlace };
  }
  const node = nodeRes.nodeModel;

  /* --- 3. Без смещения --- */
  if (offsetDirectionNodeId == null || offset <= 0) {
    antennaPlace = node.Position.toVector3();
    antennaDirectionPlace = directionNode.Position.toVector3();
    return { success: true, antennaPlace, antennaDirectionPlace };
  }

  /* --- 4. Смещение: ищем направление смещения --- */
  const nodeDirRes = mineManager.NodeDirectionManager.TryGetNodeDirectionModel(
    nodeId,
    offsetDirectionNodeId
  );
  if (!nodeDirRes.success) {
    logger.error(
      `GetAntennaPlace: Не удалось найти узел смещения с Id '${nodeId},${offsetDirectionNodeId}'`
    );
    return { success: false, antennaPlace, antennaDirectionPlace };
  }
  const nodeDirectionModel = nodeDirRes.nodeModel;

  /* --- 5. Координата с учётом смещения --- */
  const posRes = mineManager.GetPositionWithOffset(offset, nodeDirectionModel);
  if (!posRes.success) {
    logger.error("GetAntennaPlace: Не удалось вычислить смещение для антенны");
    return { success: false, antennaPlace, antennaDirectionPlace };
  }
  antennaPlace = posRes.position; // Vector3

  /* --- 6. Куда &laquo;смотрит&raquo; антенна после смещения --- */
  const dirAfterRes = mineManager.GetNodeDirectionAfterPointInDirection(
    antennaPlace,
    nodeId,
    directionNodeId
  );

  if (
    dirAfterRes.success &&
    mineManager.NodeManager.TryGetNodeModelById(dirAfterRes.endNodeId).success &&
    mineManager.NodeManager.TryGetNodeModelById(dirAfterRes.startNodeId).success
  ) {
    const endNode = mineManager.NodeManager.TryGetNodeModelById(
      dirAfterRes.endNodeId
    ).nodeModel;
    const startNode = mineManager.NodeManager.TryGetNodeModelById(
      dirAfterRes.startNodeId
    ).nodeModel;

    antennaDirectionPlace = Trigon.OffsetPointOnEndLine(
      startNode.Position.toVector3(),
      endNode.Position.toVector3(),
      10.0 /* расстояние в метрах до точки на линии */
    );
  } else {
    // fallback: берём исходный directionNode
    antennaDirectionPlace = directionNode.Position.toVector3();
  }

  return { success: true, antennaPlace, antennaDirectionPlace };
}

Ключевые моменты перевода

При желании вы можете адаптировать имена функций/классов под ваши реальные реализации — логика сохранится.

Ниже показан эквивалент метода GetNodeDirectionAfterPointInDirection на JavaScript.
Чтобы компенсировать отсутствие out‑параметров, функция возвращает объект‑результат.

js
/**
 * Найти пару узлов (startNodeId → endNodeId) такой секции, которая
 * расположена «после» заданной точки point вдоль направления
 * startNodeDirectionId → endNodeDirectionId.
 *
 * @param {Vector3} point                    – точка, от которой ищем «следующую» секцию
 * @param {number}  startNodeDirectionId     – ID стартового узла направления
 * @param {number}  endNodeDirectionId       – ID конечного узла направления
 * @param {Object}  mineManager              – объект, содержащий NodeManager, SectionManager и NodeDirectionManager
 * @param {Object}  logger                   – логгер (logger.error / logger.info)
 *
 * @returns {{
 *   success: boolean,
 *   endNodeId:  number,
 *   startNodeId: number
 * }}
 */
function getNodeDirectionAfterPointInDirection(
  point,
  startNodeDirectionId,
  endNodeDirectionId,
  mineManager,
  logger
) {
  const UNKNOWN_ID = MIMConstants.UnknownId;      // -1 или другое «неизвестное» значение
  let endNodeId   = UNKNOWN_ID;
  let startNodeId = UNKNOWN_ID;

  /* --- 1. Получаем модель направления --- */
  const dirRes = mineManager.NodeDirectionManager.TryGetNodeDirectionModel(
    startNodeDirectionId,
    endNodeDirectionId
  );
  if (!dirRes.success) {
    return { success: false, endNodeId, startNodeId };
  }
  const directionModel = dirRes.directionModel;

  /* --- 2. Читаем секции под «локом» (JS‑эквивалент блокировки) --- */
  const sections = mineManager.SectionManager.getSections(); // Map<sectionId, SectionModel>

  let nodeStart = directionModel.StartNode;      // текущий &laquo;левый&raquo; узел
  let first     = true;

  for (const sectionId of directionModel.SectionToFirstCrossroadOrDeadEnd) {
    const section = sections.get(sectionId);
    if (!section) {
      return { success: false, endNodeId: UNKNOWN_ID, startNodeId: UNKNOWN_ID };
    }

    /* --- 2.1 Проверка первой секции --- */
    if (first) {
      if (!section.OriginSection.onNode(nodeStart)) {
        return { success: false, endNodeId: UNKNOWN_ID, startNodeId: UNKNOWN_ID };
      }
      first = false;
    }

    /* --- 2.2 Узлы секции --- */
    const startNodeRes = mineManager.NodeManager.TryGetNodeModelById(nodeStart);
    if (!startNodeRes.success) {
      return { success: false, endNodeId: UNKNOWN_ID, startNodeId: UNKNOWN_ID };
    }
    const startNode = startNodeRes.nodeModel;

    const nodeEnd = section.OriginSection.getOpposite(nodeStart).Id;
    const endNodeRes = mineManager.NodeManager.TryGetNodeModelById(nodeEnd);
    if (!endNodeRes.success) {
      return { success: false, endNodeId: UNKNOWN_ID, startNodeId: UNKNOWN_ID };
    }
    const endNode = endNodeRes.nodeModel;

    /* --- 2.3 Лежит ли point на векторе start &rarr; end? --- */
    if (onVector(startNode.Position.toVector3(), endNode.Position.toVector3(), point)) {
      endNodeId   = nodeEnd;
      startNodeId = startNode.Id;
      break;
    }

    /* --- 2.4 Переходим к следующей секции --- */
    nodeStart = nodeEnd;
  }

  return { success: endNodeId !== UNKNOWN_ID, endNodeId, startNodeId };

  /* ---------------------------------------------------------------- */
  /** Проверка: принадлежит ли точка отрезку v1‑v2 (с погрешностью ~1 м). */
  function onVector(v1, v2, nPoint) {
    if (
      Vector3.distanceSquared(v1, nPoint) < 1 ||
      Vector3.distanceSquared(v2, nPoint) < 1
    ) {
      return true;
    }

    const v1n = v1.subtract(nPoint);
    const v2n = v2.subtract(nPoint);

    const angleRad = v1n.angleBetween(v2n);           // угол в радианах
    const deg      = Trigon.radianToDegree(angleRad); // &rarr; градусы

    // Если угол &asymp; 180°, точка лежит на прямой (коллинеарна)
    return Math.abs(Math.round(deg) - 180) <= 0;
  }
}

Что изменилось по сравнению с C#

При необходимости адаптируйте имена методов (getSections, TryGetNodeModelById, angleBetween, т.д.) к реальному коду вашего проекта — логика останется прежней.