GoJS - create polygon from planogram sample

From small items of this sample (https://gojs.net/latest/samples/planogram.html) to polygon.

function getTopLeft(A){
    let x = y = Number.MAX_VALUE;
    let aux;
    A.forEach(function(e){
        let eX = parseInt(e.pos.split(' ')[0]);
        let eY = parseInt(e.pos.split(' ')[1]);
        if(eY < y){
            y = eY;
            x = eX;
            aux = e;
        }
        else if(eY == y){
            if(eX <= x){
                x = eX;
                aux = e;
            }
        }
    })
    return aux;
}

function rowSort(A){
    let sortedArray = [];
    while(A.length > 0){
        let node = getTopLeft(A);
        let index = A.indexOf(node);
        sortedArray.push(node);
        A.splice(index,1);
    }
    return sortedArray;
}

function pushEdges(node, container, cell_size){
    let x = parseInt(node.pos.split(' ')[0]);
    let y = parseInt(node.pos.split(' ')[1]);
    let horizontalEdgeTop, horizontalEdgeBottom, verticalEdgeLeft, verticalEdgeRight;
    let h = x+cell_size;
    let v = y+cell_size;
    horizontalEdgeTop = "M,"+x+','+y+",H,"+h+' '; // "M "+x+' '+y+" H "+h+' ';
    horizontalEdgeBottom = "M,"+x+','+v+",H,"+h+' '; // "M "+x+' '+v+" H "+h+' ';
    verticalEdgeLeft = "M,"+x+','+y+",V,"+v+' '; // "M "+x+' '+y+" V "+v+' ';
    verticalEdgeRight = "M,"+h+','+y+",V,"+v+' '; // "M "+h+' '+y+" V "+v+' ';
    container.edges.push(horizontalEdgeTop);
    container.edges.push(horizontalEdgeBottom);
    container.edges.push(verticalEdgeLeft);
    container.edges.push(verticalEdgeRight);
}

function searchEdges(A, cell_size){
    let straightLines = [];
    let edgesContainer = {
        edges: straightLines
    }
    A.forEach(function(e){
        pushEdges(e, edgesContainer, cell_size);
    })
    return edgesContainer.edges;
}

function deleteAdjEdges(container){
    let A = container.edges;
    //costruisco una mappa contenente tutti gli elementi che hanno un duplicato
    let uniq = A
                .map((edge)=>{
                    return {count: 1, edge: edge}
                })
                .reduce((a,b)=>{
                    a[b.edge] = (a[b.edge] || 0) + b.count
                    return a
                }, {})
    let duplicates = Object.keys(uniq).filter((a)=>uniq[a] > 1);
    //elimino i duplicati
    while(duplicates.length > 0){
        let index = container.edges.indexOf(duplicates[0]);
        while(index != -1){
            container.edges.splice(index, 1);
            index = container.edges.indexOf(duplicates[0]);
        }
        let dupIndex = duplicates.indexOf(duplicates[0]);
        duplicates.splice(dupIndex, 1);
    }
}

/**
 * Cerco il prossimo lato da inserire nell'array degli ordinati in senso orario
 * @param {edges[]} A
 * @param {int} x
 * @param {int} y
 * @param {char} dirS
 * @param {int} endP
 * @param {char} dir
 */
var getNextEdge = function (A, x, y, dirS, endP, dir, first, reverse) {
  if (dir == 'H') {
    if (dirS == 'H') {
      for (let i = 0; i < A.length; i++){
        if ((parseInt(A[i].split(',')[1]) == endP) && (parseInt(A[i].split (',')[2]) == y) && (A[i].split(',')[3] == 'H')){ // A[i].x == endP && A[i].y == y && A[i].dir == H
          if ( y == (parseInt(A[i].split(',')[2])) && !first && reverse ){
            return null;
          } else {
            return A[i];
          } // if - else
        } // if
      } // for
      return null;
    } else if (dirS == 'V') {
      for(let i = 0; i < A.length; i++){
        if ((parseInt(A[i].split(',')[1]) == x) && (parseInt(A[i].split(',')[2]) == endP) && (A[i].split(',')[3] == 'H')){ // A[i].x == x && A[i].y == endP && A[i].dir == H
            if(first){
                return null;
            }
            else{
                return A[i];
            }
        } // if
      } // for
      return null;
    } // if - else
  } else if (dir == 'V'){
        if(dirS == 'H'){
            for(let i = 0; i < A.length; i++){
                if((parseInt(A[i].split(',')[1]) == endP) && (parseInt(A[i].split(',')[2]) == y) && (A[i].split(',')[3] == 'V')){ // A[i].x == endP && A[i].y == y && A[i].dir == V
                    return A[i];
                }
            }
            return null;
        }
        else if(dirS == 'V'){
            for(let i = 0; i < A.length; i++){
                if((parseInt(A[i].split(',')[1]) == x) && (parseInt(A[i].split(',')[2]) == endP) && (A[i].split(',')[3] == 'V')){ // A[i].x == x && A[i].y == endP && A[i].dir == V
                    return A[i];
                }
            }
            return null;
        }
    }
} // getNextEdge

/**
 * Dato l'array di tutti i lati (esclusi gli adiancenti) li ordina in senso orario
 * @param {edges[]} edges
 * @param {int} cell_size
 */
function sortEdges(edges, cell_size){
    let reverse = false;
    let first = true;
    let nullFromReverse = false;
    let sortedEdges = [];// inizializzo l'array di lati ordinati
    sortedEdges.push(edges[0]);// pusho sicuramente il primo dei miei lati, che è certamente il primo da inserire
    edges.splice(0, 1);// elimino dall'array dei lati quello appena inserito
    let x, y, endP;
    while(edges.length > 0){
        if(!reverse){
            x = parseInt(sortedEdges[sortedEdges.length-1].split(',')[1]);
            y =  parseInt(sortedEdges[sortedEdges.length-1].split(',')[2]);
        }
        if(!nullFromReverse){
            endP =  parseInt(sortedEdges[sortedEdges.length-1].split(',')[4]);
        }
        else{
            x = parseInt(sortedEdges[sortedEdges.length-1].split(',')[1]);
            y =  parseInt(sortedEdges[sortedEdges.length-1].split(',')[2]);
            first = true;
        }
        let dirS =  sortedEdges[sortedEdges.length-1].split(',')[3];
        let edge = getNextEdge(edges, x, y, dirS, endP, 'H', first, reverse);
        if(edge){ // abbiamo un lato H da inserire
            first = false;
            if(reverse){
                endP = parseInt(edge.split(',')[4])-cell_size;
                x = parseInt(edge.split(',')[1]);
                y = parseInt(edge.split(',')[2])
                newEdge = "M,"+x+','+y+",H,"+endP+' ';
                sortedEdges.push(newEdge);
                reverse = false;
            }
            else{
                sortedEdges.push(edge);
            }
            let index = edges.indexOf(edge);
            edges.splice(index, 1);
            nullFromReverse = false;
        }
        else{ // non abbiamo un lato H da inserire, interrogo per V
            edge = getNextEdge(edges, x, y, dirS, endP, 'V', first, reverse);
            if(edge){ // abbiamo un lato V da inserire
                first = false;
                if(reverse){
                    endP = parseInt(edge.split(',')[4])-cell_size;
                    x = parseInt(edge.split(',')[1]);
                    y = parseInt(edge.split(',')[2])
                    newEdge = "M,"+x+','+y+",V,"+endP+' ';
                    sortedEdges.push(newEdge);
                    reverse = false;
                    nullFromReverse = false;
                }
                else{
                    sortedEdges.push(edge);
                }
                let index = edges.indexOf(edge);
                edges.splice(index, 1);
            }
            else if(!reverse){// Non abbiamo nè un H né un V, quindi ribaltiamo
                if(dirS == 'V'){
                    x = x-cell_size;
                    y = y+cell_size;
                }
                else{
                    y = y-cell_size;
                    x = x+cell_size;
                }
                reverse = true;
            }
            else{
                endP = endP-cell_size;
                nullFromReverse = true;
            }
        }
    }
    return sortedEdges;
}

function createString(A){
    let M = A[0].split(',')[0];
    let Mx = A[0].split(',')[1];
    let My = A[0].split(',')[2];
    let dir = A[0].split(',')[3];
    let endSpot = A[0].split(',')[4];
    let path = "F "+M+' '+Mx+' '+My+' '+dir+' '+endSpot;
    A.splice(0, 1);
    A.forEach(function(e){
        let dir = e.split(',')[3];
        let endSpot = e.split(',')[4];
        path = path.concat(' '+dir+' '+endSpot);
    })
    return path;
}

var fig2 = [
    {"key":"g", "color":"#B2FF59", "pos":"0 0", "group":"G1"},
    {"key":"g2", "color":"#B2FF59", "pos":"0 50", "group":"G1"},
    {"key":"g3", "color":"#B2FF59", "pos":"50 50", "group":"G1"},
    {"key":"g4", "color":"#B2FF59", "pos":"100 0", "group":"G1"},
    {"key":"g5", "color":"#B2FF59", "pos":"100 50", "group":"G1"},
    {"key":"g6", "color":"#B2FF59", "pos":"150 50", "group":"G1"},
    {"key":"g7", "color":"#B2FF59", "pos":"100 100", "group":"G1"},
    {"key":"g8", "color":"#B2FF59", "pos":"50 100", "group":"G1"},
    {"key":"g9", "color":"#B2FF59", "pos":"50 150", "group":"G1"},
    {"key":"g10", "color":"#B2FF59", "pos":"100 150", "group":"G1"}
]

var sortedShape = rowSort(fig2);
var edges = searchEdges(sortedShape, 50);
var container = {
    edges: edges
};
deleteAdjEdges(container);
var sortedEdges = sortEdges(container.edges, 50);
var path = createString(sortedEdges);
}