| 
/* 
 | 
* Licensed to the Apache Software Foundation (ASF) under one 
 | 
* or more contributor license agreements.  See the NOTICE file 
 | 
* distributed with this work for additional information 
 | 
* regarding copyright ownership.  The ASF licenses this file 
 | 
* to you under the Apache License, Version 2.0 (the 
 | 
* "License"); you may not use this file except in compliance 
 | 
* with the License.  You may obtain a copy of the License at 
 | 
* 
 | 
*   http://www.apache.org/licenses/LICENSE-2.0 
 | 
* 
 | 
* Unless required by applicable law or agreed to in writing, 
 | 
* software distributed under the License is distributed on an 
 | 
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 
 | 
* KIND, either express or implied.  See the License for the 
 | 
* specific language governing permissions and limitations 
 | 
* under the License. 
 | 
*/ 
 | 
  
 | 
  
 | 
/** 
 | 
 * AUTO-GENERATED FILE. DO NOT MODIFY. 
 | 
 */ 
 | 
  
 | 
/* 
 | 
* Licensed to the Apache Software Foundation (ASF) under one 
 | 
* or more contributor license agreements.  See the NOTICE file 
 | 
* distributed with this work for additional information 
 | 
* regarding copyright ownership.  The ASF licenses this file 
 | 
* to you under the Apache License, Version 2.0 (the 
 | 
* "License"); you may not use this file except in compliance 
 | 
* with the License.  You may obtain a copy of the License at 
 | 
* 
 | 
*   http://www.apache.org/licenses/LICENSE-2.0 
 | 
* 
 | 
* Unless required by applicable law or agreed to in writing, 
 | 
* software distributed under the License is distributed on an 
 | 
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 
 | 
* KIND, either express or implied.  See the License for the 
 | 
* specific language governing permissions and limitations 
 | 
* under the License. 
 | 
*/ 
 | 
import { prepareDataCoordInfo, getStackedOnPoint } from './helper.js'; 
 | 
import { createFloat32Array } from '../../util/vendor.js'; 
 | 
function diffData(oldData, newData) { 
 | 
  var diffResult = []; 
 | 
  newData.diff(oldData).add(function (idx) { 
 | 
    diffResult.push({ 
 | 
      cmd: '+', 
 | 
      idx: idx 
 | 
    }); 
 | 
  }).update(function (newIdx, oldIdx) { 
 | 
    diffResult.push({ 
 | 
      cmd: '=', 
 | 
      idx: oldIdx, 
 | 
      idx1: newIdx 
 | 
    }); 
 | 
  }).remove(function (idx) { 
 | 
    diffResult.push({ 
 | 
      cmd: '-', 
 | 
      idx: idx 
 | 
    }); 
 | 
  }).execute(); 
 | 
  return diffResult; 
 | 
} 
 | 
export default function lineAnimationDiff(oldData, newData, oldStackedOnPoints, newStackedOnPoints, oldCoordSys, newCoordSys, oldValueOrigin, newValueOrigin) { 
 | 
  var diff = diffData(oldData, newData); 
 | 
  // let newIdList = newData.mapArray(newData.getId); 
 | 
  // let oldIdList = oldData.mapArray(oldData.getId); 
 | 
  // convertToIntId(newIdList, oldIdList); 
 | 
  // // FIXME One data ? 
 | 
  // diff = arrayDiff(oldIdList, newIdList); 
 | 
  var currPoints = []; 
 | 
  var nextPoints = []; 
 | 
  // Points for stacking base line 
 | 
  var currStackedPoints = []; 
 | 
  var nextStackedPoints = []; 
 | 
  var status = []; 
 | 
  var sortedIndices = []; 
 | 
  var rawIndices = []; 
 | 
  var newDataOldCoordInfo = prepareDataCoordInfo(oldCoordSys, newData, oldValueOrigin); 
 | 
  // const oldDataNewCoordInfo = prepareDataCoordInfo(newCoordSys, oldData, newValueOrigin); 
 | 
  var oldPoints = oldData.getLayout('points') || []; 
 | 
  var newPoints = newData.getLayout('points') || []; 
 | 
  for (var i = 0; i < diff.length; i++) { 
 | 
    var diffItem = diff[i]; 
 | 
    var pointAdded = true; 
 | 
    var oldIdx2 = void 0; 
 | 
    var newIdx2 = void 0; 
 | 
    // FIXME, animation is not so perfect when dataZoom window moves fast 
 | 
    // Which is in case remvoing or add more than one data in the tail or head 
 | 
    switch (diffItem.cmd) { 
 | 
      case '=': 
 | 
        oldIdx2 = diffItem.idx * 2; 
 | 
        newIdx2 = diffItem.idx1 * 2; 
 | 
        var currentX = oldPoints[oldIdx2]; 
 | 
        var currentY = oldPoints[oldIdx2 + 1]; 
 | 
        var nextX = newPoints[newIdx2]; 
 | 
        var nextY = newPoints[newIdx2 + 1]; 
 | 
        // If previous data is NaN, use next point directly 
 | 
        if (isNaN(currentX) || isNaN(currentY)) { 
 | 
          currentX = nextX; 
 | 
          currentY = nextY; 
 | 
        } 
 | 
        currPoints.push(currentX, currentY); 
 | 
        nextPoints.push(nextX, nextY); 
 | 
        currStackedPoints.push(oldStackedOnPoints[oldIdx2], oldStackedOnPoints[oldIdx2 + 1]); 
 | 
        nextStackedPoints.push(newStackedOnPoints[newIdx2], newStackedOnPoints[newIdx2 + 1]); 
 | 
        rawIndices.push(newData.getRawIndex(diffItem.idx1)); 
 | 
        break; 
 | 
      case '+': 
 | 
        var newIdx = diffItem.idx; 
 | 
        var newDataDimsForPoint = newDataOldCoordInfo.dataDimsForPoint; 
 | 
        var oldPt = oldCoordSys.dataToPoint([newData.get(newDataDimsForPoint[0], newIdx), newData.get(newDataDimsForPoint[1], newIdx)]); 
 | 
        newIdx2 = newIdx * 2; 
 | 
        currPoints.push(oldPt[0], oldPt[1]); 
 | 
        nextPoints.push(newPoints[newIdx2], newPoints[newIdx2 + 1]); 
 | 
        var stackedOnPoint = getStackedOnPoint(newDataOldCoordInfo, oldCoordSys, newData, newIdx); 
 | 
        currStackedPoints.push(stackedOnPoint[0], stackedOnPoint[1]); 
 | 
        nextStackedPoints.push(newStackedOnPoints[newIdx2], newStackedOnPoints[newIdx2 + 1]); 
 | 
        rawIndices.push(newData.getRawIndex(newIdx)); 
 | 
        break; 
 | 
      case '-': 
 | 
        pointAdded = false; 
 | 
    } 
 | 
    // Original indices 
 | 
    if (pointAdded) { 
 | 
      status.push(diffItem); 
 | 
      sortedIndices.push(sortedIndices.length); 
 | 
    } 
 | 
  } 
 | 
  // Diff result may be crossed if all items are changed 
 | 
  // Sort by data index 
 | 
  sortedIndices.sort(function (a, b) { 
 | 
    return rawIndices[a] - rawIndices[b]; 
 | 
  }); 
 | 
  var len = currPoints.length; 
 | 
  var sortedCurrPoints = createFloat32Array(len); 
 | 
  var sortedNextPoints = createFloat32Array(len); 
 | 
  var sortedCurrStackedPoints = createFloat32Array(len); 
 | 
  var sortedNextStackedPoints = createFloat32Array(len); 
 | 
  var sortedStatus = []; 
 | 
  for (var i = 0; i < sortedIndices.length; i++) { 
 | 
    var idx = sortedIndices[i]; 
 | 
    var i2 = i * 2; 
 | 
    var idx2 = idx * 2; 
 | 
    sortedCurrPoints[i2] = currPoints[idx2]; 
 | 
    sortedCurrPoints[i2 + 1] = currPoints[idx2 + 1]; 
 | 
    sortedNextPoints[i2] = nextPoints[idx2]; 
 | 
    sortedNextPoints[i2 + 1] = nextPoints[idx2 + 1]; 
 | 
    sortedCurrStackedPoints[i2] = currStackedPoints[idx2]; 
 | 
    sortedCurrStackedPoints[i2 + 1] = currStackedPoints[idx2 + 1]; 
 | 
    sortedNextStackedPoints[i2] = nextStackedPoints[idx2]; 
 | 
    sortedNextStackedPoints[i2 + 1] = nextStackedPoints[idx2 + 1]; 
 | 
    sortedStatus[i] = status[idx]; 
 | 
  } 
 | 
  return { 
 | 
    current: sortedCurrPoints, 
 | 
    next: sortedNextPoints, 
 | 
    stackedOnCurrent: sortedCurrStackedPoints, 
 | 
    stackedOnNext: sortedNextStackedPoints, 
 | 
    status: sortedStatus 
 | 
  }; 
 | 
} 
 |