static calculateBounds()

in packages/core/src/utils/path.ts [236:314]

• 72 lines of code
• 8 McCabe index (conditional complexity)

  static calculateBounds(path: Directive[]) {
    const aX = []
    const aY = []
    let current: Directive
    let subpathStartX = 0
    let subpathStartY = 0
    let x = 0
    let y = 0
    let bounds: { x: number, y: number }[]
    for (let i = 0, n = path.length; i < n; ++i) {
      current = path[i]
      switch (current[0]) {

        case 'L':
          x = current[1]
          y = current[2]
          bounds = []
          break

        case 'M':
          x = current[1]
          y = current[2]
          subpathStartX = x
          subpathStartY = y
          bounds = []
          break

        case 'C':
          bounds = getBoundsOfCurve(x, y,
            current[1],
            current[2],
            current[3],
            current[4],
            current[5],
            current[6]
          )
          x = current[5]
          y = current[6]
          break

        case 'Q':
          bounds = getBoundsOfCurve(x, y,
            current[1],
            current[2],
            current[1],
            current[2],
            current[3],
            current[4]
          )
          x = current[3]
          y = current[4]
          break

        case 'z':
        case 'Z':
          x = subpathStartX
          y = subpathStartY
          break
      }
      bounds!.forEach(function (point) {
        aX.push(point.x)
        aY.push(point.y)
      })
      aX.push(x)
      aY.push(y)
    }

    const minX = Math.min(...aX),
      minY = Math.min(...aY),
      maxX = Math.max(...aX),
      maxY = Math.max(...aY)

    return Rect.fromLTRB(
      minX,
      minY,
      maxX,
      maxY,
    )
  }