html5 applet fly into the shopping cart (放物線描画モーショントラック・ポイント)

/**
* Fly-in cart, track point drawing
* @author ????
* @param {Array} start` Insert code snippet here `Point starting point clientX, clientY values (required) 
* @param {Array} endPoint endpoint clientX, clientY values (required)
* @param {number} point Number of points (required) 
* @param {number} h the height of the parabola upwards (upward motion) (optional)
* @param {number} hclientX The value of clientX when the highest point is reached in the presence of h.
* @return {Array} [ left ,top ] array of values
*/
function flycart(startPoint, endPoint, point, h = 0, hclientX) {
   /* 
   Set startPoint to (0,0), the parabola passes through (0,0), and the model relation y = ax^2 + bx or y = ax^ 2 can be derived.
   1 When there is h, the parabola will be shifted upward by h on the y-axis, in which case the relation y = ax^2 + bx
   2 When there is no h, the parabola startPoint is the vertex, and the relation y = ax^2 
   */

   /* Parameter validation */
   function Validityparameter() {
       let isOkey = true
       Array.isArray(startPoint) && startPoint.length ! == 2 && (isOkey = false)
       Array.isArray(endPoint) && endPoint.length ! == 2 && (isOkey = false)
           (point.constructor ! == Number) && (isOkey = false)
       return isOkey
   }

   /* Parameter validation */
   if (!Validityparameter()) {
       return []
   }

   /* horizontal coordinates of point A */
   const xA = 0
   /* the vertical coordinate of point A */
   const yA = 0
   /* x-axis offset */
   const offsetX = startPoint[0]
   /* y-axis offset */
   const offsetY = startPoint[1]
   /* horizontal coordinate of point B */
   const xB = endPoint[0] - offsetX
   /* B vertical coordinate */
   const yB = endPoint[1] - offsetY

   /* coefficients a,b based on the coordinates of point B and the maximum height h */
   let b = 0
   let a = 0

   /* Calculate the coefficients a ,b */
   function handerComputer() {
       if (h < 10) {
           a = yB / Math.pow(xB, 2)
       } else {
           /* Since the general cart case is down, we actually have the cart coordinate system reversed, so we'll set h to a negative value here */
           h = -h
           /* Solve a,b quadratically, now knowing a point ( xB , yB ) another point (maxHx, h) */
           /* the x coordinate when the highest point is effectively reached */
           const effectMaHx = hclientX && Math.abs(hclientX - offsetX) > 0 && Math.abs(hclientX - offsetX) < Math.abs(xB)
           /* If hclientX does not meet the requirement, then choose A , B midpoint as */
           let maxHx = effectMaHx ? (hclientX - offsetX) : (xB + xA) / 2
           /* We know the two points and find the values of a , b. Solve the equation to get y = ax^2 + bx */
           a = ((yB / xB) - (h / maxHx)) / (xB - maxHx)
           /* Bring a into one of the solutions b */
           b = (yB - a * Math.pow(xB, 2)) / xB
       }
   }


   /* Array of trajectories */
   const travelList = []
   /* x evenly divided */
   const averageX = (xB - xA) / point

   /* Handle linear motion */
   function handerLinearMotion(type) {
       if (type === 'X') {
           const averageY = (yB - yA) / point
           for (let i = 1; i <= point; i++) {
               travelList.push([offsetX, i * averageY + offsetY])
           }
       } else {
           for (let i = 1; i <= point; i++) {
               travelList.push([offsetX + i * averageX, offsetY])
           }
       }
       return travelList
   }

   /* When the absolute value of xB is less than 10, we treat it as a straight-line operation on the y-axis */
   if (Math.abs(xB) < 10) {
       return handerLinearMotion('X')
   }
   /* When the absolute value of yB is less than 10, we treat it as x-axis linear motion */
   if (Math.abs(yB) < 10) {
       return handerLinearMotion('Y')
   }

   handerComputer()
   /* Draw the path */
   for (let i = 1; i <= point; i++) {
       const currentX = averageX * i
       const currentY = Math.pow(currentX, 2) * a + b * currentX - yA
       travelList.push([currentX + offsetX, currentY + offsetY])
   }

   return travelList
}

export default flycart

 startCart(){
    /* open cart */
    /* this.start stores the start point clientY clientY ,this.end stores the final point clientX clientY */
    this.start = {}
    this.start['x'] = this.data.current['x']
    this.start['y'] = this.data.current['y']
    const travelList = flycart([ this.start['x'] , this.start['y'] ] ,[ this.end['x'] , this.end['y'] ],25,50 )
    this.startAnimate(travelList)
        },
 startAnimate(travelList) {
    let index = 0
    this.setData({
        cartHidden: false,
        bus_x: this.start['x'],
        bus_y: this.start['y']
    })
    if(travelList.length=== 0) return
    this.timer = setInterval( ()=> {
        index++
        const currentPoint = travelList.shift()
        this.setData({
            bus_x: currentPoint[0],
            bus_y: currentPoint[1],
            scale: 1 - index / 25
        })
        if (travelList.length === 0) {
            clearInterval(this.timer)
            this.triggerEvent('close')
        }
    }, 33)
}