text: 
  /*
  * 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.
   */
  
  import { forceLayout } from './forceHelper';
  import { simpleLayout } from './simpleLayoutHelper';
  import { circularLayout } from './circularLayoutHelper';
  import { linearMap } from '../../util/number';
  import * as vec2 from 'zrender/esm/core/vector';
  import * as zrUtil from 'zrender/esm/core/util';
  import { getCurvenessForEdge } from '../helper/multipleGraphEdgeHelper';
  export default function graphForceLayout(ecModel) {
    ecModel.eachSeriesByType('graph', function (graphSeries) {
      var coordSys = graphSeries.coordinateSystem;
  
      if (coordSys && coordSys.type !== 'view') {
        return;
      }
  
      if (graphSeries.get('layout') === 'force') {
        var preservedPoints_1 = graphSeries.preservedPoints || {};
        var graph_1 = graphSeries.getGraph();
        var nodeData_1 = graph_1.data;
        var edgeData = graph_1.edgeData;
        var forceModel = graphSeries.getModel('force');
        var initLayout = forceModel.get('initLayout');
  
        if (graphSeries.preservedPoints) {
          nodeData_1.each(function (idx) {
            var id = nodeData_1.getId(idx);
            nodeData_1.setItemLayout(idx, preservedPoints_1[id] || [NaN, NaN]);
          });
        } else if (!initLayout || initLayout === 'none') {
          simpleLayout(graphSeries);
        } else if (initLayout === 'circular') {
          circularLayout(graphSeries, 'value');
        }
  
        var nodeDataExtent_1 = nodeData_1.getDataExtent('value');
        var edgeDataExtent_1 = edgeData.getDataExtent('value');
        var repulsion = forceModel.get('repulsion');
        var edgeLength = forceModel.get('edgeLength');
        var repulsionArr_1 = zrUtil.isArray(repulsion) ? repulsion : [repulsion, repulsion];
        var edgeLengthArr_1 = zrUtil.isArray(edgeLength) ? edgeLength : [edgeLength, edgeLength];
        edgeLengthArr_1 = [edgeLengthArr_1[1], edgeLengthArr_1[0]];
        var nodes_1 = nodeData_1.mapArray('value', function (value, idx) {
          var point = nodeData_1.getItemLayout(idx);
          var rep = linearMap(value, nodeDataExtent_1, repulsionArr_1);
  
          if (isNaN(rep)) {
            rep = (repulsionArr_1[0] + repulsionArr_1[1]) / 2;
          }
  
          return {
            w: rep,
            rep: rep,
            fixed: nodeData_1.getItemModel(idx).get('fixed'),
            p: !point || isNaN(point[0]) || isNaN(point[1]) ? null : point
          };
        });
        var edges = edgeData.mapArray('value', function (value, idx) {
          var edge = graph_1.getEdgeByIndex(idx);
          var d = linearMap(value, edgeDataExtent_1, edgeLengthArr_1);
  
          if (isNaN(d)) {
            d = (edgeLengthArr_1[0] + edgeLengthArr_1[1]) / 2;
          }
  
          var edgeModel = edge.getModel();
          var curveness = zrUtil.retrieve3(edge.getModel().get(['lineStyle', 'curveness']), -getCurvenessForEdge(edge, graphSeries, idx, true), 0);
          return {
            n1: nodes_1[edge.node1.dataIndex],
            n2: nodes_1[edge.node2.dataIndex],
            d: d,
            curveness: curveness,
            ignoreForceLayout: edgeModel.get('ignoreForceLayout')
          };
        });
        var rect = coordSys.getBoundingRect();
        var forceInstance = forceLayout(nodes_1, edges, {
          rect: rect,
          gravity: forceModel.get('gravity'),
          friction: forceModel.get('friction')
        });
        forceInstance.beforeStep(function (nodes, edges) {
          for (var i = 0, l = nodes.length; i < l; i++) {
            if (nodes[i].fixed) {
              vec2.copy(nodes[i].p, graph_1.getNodeByIndex(i).getLayout());
            }
          }
        });
        forceInstance.afterStep(function (nodes, edges, stopped) {
          for (var i = 0, l = nodes.length; i < l; i++) {
            if (!nodes[i].fixed) {
              graph_1.getNodeByIndex(i).setLayout(nodes[i].p);
            }
  
            preservedPoints_1[nodeData_1.getId(i)] = nodes[i].p;
          }
  
          for (var i = 0, l = edges.length; i < l; i++) {
            var e = edges[i];
            var edge = graph_1.getEdgeByIndex(i);
            var p1 = e.n1.p;
            var p2 = e.n2.p;
            var points = edge.getLayout();
            points = points ? points.slice() : [];
            points[0] = points[0] || [];
            points[1] = points[1] || [];
            vec2.copy(points[0], p1);
            vec2.copy(points[1], p2);
  
            if (+e.curveness) {
              points[2] = [(p1[0] + p2[0]) / 2 - (p1[1] - p2[1]) * e.curveness, (p1[1] + p2[1]) / 2 - (p2[0] - p1[0]) * e.curveness];
            }
  
            edge.setLayout(points);
          }
        });
        graphSeries.forceLayout = forceInstance;
        graphSeries.preservedPoints = preservedPoints_1;
        forceInstance.step();
      } else {
        graphSeries.forceLayout = null;
      }
    });
  }