Trouble with Easing Dynamic Layer Sorting Transitions in After Effects Expression

Hey Dan thanks again for the hint and the helping hand! 
This is my solution now, and it works 🙂 ... juhuuu ...
Took me quit a while!
One problem I was just figuring out at last, i was always working with "transform.position.valueAtTime(time)" so figure out what the position of the layer is right now. But it somehow always was the wrong postition value , so i had to calculated it with the last rank. Kind of simple but took me a while :D...

// Initialize variables
var textValues = [];
var rankChangeTime = 0;
var oldRank = 0; // Store the previous rank
var moverPos = thisComp.layer("MOVER").transform.position.value;

// Get transition duration from the "Controller" slider
var transitionDuration = thisComp.layer("Controller").effect("Transition Duration")(1);

// Gather all text values and their layer indices
for (var i = 1; i <= thisComp.numLayers; i++) {
    var layer = thisComp.layer(i);
    if (layer.name.match(/^Item\d+$/)) { // Check for matching layer names
        var textValue = parseFloat(layer.effect("Value")(1).value);
        if (!isNaN(textValue)) {
            textValues.push({value: textValue, index: i});
        }
    }
}

// Sort the text values in descending order
textValues.sort(function(a, b) {
    return b.value - a.value;
});

// Find the current layer's index in the sorted array
var currentIndex = textValues.findIndex(function(element) {
    return element.index == index;
});

// Check for rank changes by iterating backward in time
var lastRank = currentIndex;
for (var t = time; t >= thisComp.displayStartTime; t -= thisComp.frameDuration) {
    var sortedAtTime = textValues.slice(); // Clone the array
    for (var j = 0; j < sortedAtTime.length; j++) {
        var layerAtTime = thisComp.layer(sortedAtTime[j].index);
        sortedAtTime[j].value = parseFloat(layerAtTime.effect("Value")(1).valueAtTime(t));
    }
    sortedAtTime.sort(function(a, b) {
        return b.value - a.value;
    });
    var rankAtTime = sortedAtTime.findIndex(function(element) {
        return element.index == index;
    });

    if (rankAtTime != lastRank) {
        rankChangeTime = t; // Store the time of rank change
        oldRank = rankAtTime; // Store the old rank based on sorting, not position
        break;
    }
}

// Calculate the time difference from the current time
var timeSinceChange = time - rankChangeTime;

// Calculate the Y positions based on rank, not transform position
var baseY = thisComp.layer("Controller").effect("Base Y")(1);
var spacing = thisComp.layer("Controller").effect("Spacing")(1);
var newY = baseY + currentIndex * spacing;
var oldY = baseY + oldRank * spacing; // Calculate oldY based on old rank

// Interpolate the position
var easedY = ease(Math.min(timeSinceChange / transitionDuration, 1), oldY, newY);

[moverPos[0], easedY+moverPos[1]];