Is it possible to capture the previous mouse action (the direction in which the object was moved)?

The forum structure is far too messy I’m just gonna tag on here ​@rob day ​ ​@dublove 

Rob, I figured an event listener was the only way, but struggled to think of a way without two scripts, but thanks for your code, I hadn’t touched the script yet as I was still trying to figure out what DubLove is trying to do. But alas, we have landed on something that I think works. 

​@m1b I tried the Transform Again already and it’s not reliable enough and couldn’t dig into it for movement only.

I had a far longerpost but lost it with a single click of CANCEL instead of SEND, and of course the forum doesn’t save it, or ask if you cancel you lose your progress… no warning.. 

Anyway I digress

-----------------------------------------------------

I think we all agree an event listener is needed

So I made a startup script

Make a Startup Scripts folder outside your Scripts Panel folder - (it’s under the highlighted one)

Inside the Startup Scripts folder put this - then RESTART INDESIGN

#target "InDesign"
#targetengine "session"

(function () {
    var SCRIPT_NAME = "Direction Watch Startup";
    var LABEL_PREFIX = "ET_DirectionWatch_";
    var MIN_MOVE = 0.001;

    if ($.global.ET_DirectionWatchInstalled) {
        return;
    }

    $.global.ET_DirectionWatchInstalled = true;
    $.global.ET_DirectionWatchSnapshot = getSelectionSnapshot();

    app.eventListeners.add("afterSelectionChanged", function () {
        $.global.ET_DirectionWatchSnapshot = getSelectionSnapshot();
    });

    app.eventListeners.add("afterSelectionAttributeChanged", function () {
        var oldSnapshot = $.global.ET_DirectionWatchSnapshot;
        var newSnapshot = getSelectionSnapshot();

        if (!oldSnapshot || !newSnapshot) {
            $.global.ET_DirectionWatchSnapshot = newSnapshot;
            return;
        }

        if (oldSnapshot.signature !== newSnapshot.signature) {
            $.global.ET_DirectionWatchSnapshot = newSnapshot;
            return;
        }

        var dx = newSnapshot.bounds[1] - oldSnapshot.bounds[1];
        var dy = newSnapshot.bounds[0] - oldSnapshot.bounds[0];

        if (Math.abs(dx) < MIN_MOVE && Math.abs(dy) < MIN_MOVE) {
            $.global.ET_DirectionWatchSnapshot = newSnapshot;
            return;
        }

        var direction;

        if (Math.abs(dx) >= Math.abs(dy)) {
            direction = dx < 0 ? "left" : "right";
        }
        else {
            direction = dy < 0 ? "up" : "down";
        }

        app.insertLabel(LABEL_PREFIX + "direction", direction);
        app.insertLabel(LABEL_PREFIX + "dx", String(dx));
        app.insertLabel(LABEL_PREFIX + "dy", String(dy));
        app.insertLabel(LABEL_PREFIX + "time", String(new Date().getTime()));

        $.global.ET_DirectionWatchSnapshot = newSnapshot;
    });

    function getSelectionSnapshot() {
        if (!canReadSelection()) {
            return null;
        }

        var items = [];
        var selection;

        try {
            selection = app.selection;
        }
        catch (_) {
            return null;
        }

        for (var i = 0; i < selection.length; i++) {
            if (selection[i] && selection[i].isValid && hasBounds(selection[i])) {
                items.push(selection[i]);
            }
        }

        if (items.length === 0) {
            return null;
        }

        return {
            signature: getSelectionSignature(items),
            bounds: getSelectionBounds(items)
        };
    }

    function canReadSelection() {
        try {
            return app.documents.length > 0 && app.layoutWindows.length > 0;
        }
        catch (_) {
            return false;
        }
    }

    function getSelectionSignature(items) {
        var ids = [];

        for (var i = 0; i < items.length; i++) {
            ids.push(String(items[i].id));
        }

        ids.sort();
        return ids.join(",");
    }

    function getSelectionBounds(items) {
        var b = items[0].geometricBounds;
        var top = b[0];
        var left = b[1];
        var bottom = b[2];
        var right = b[3];

        for (var i = 1; i < items.length; i++) {
            b = items[i].geometricBounds;
            top = Math.min(top, b[0]);
            left = Math.min(left, b[1]);
            bottom = Math.max(bottom, b[2]);
            right = Math.max(right, b[3]);
        }

        return [top, left, bottom, right];
    }

    function hasBounds(item) {
        try {
            var gb = item.geometricBounds;
            return gb && gb.length === 4;
        }
        catch (_) {
            return false;
        }
    }
}());

====================================================================

NOW THE SCRIPT TO LiSTEN TO MOVEMENT IS RUNNING WHEN INDESIGN STARTS

====================================================================

Put this into the normal scripts folder - this is the one you run when you want to move items to a certain guide. 

#target "InDesign"

(function () {
    var SCRIPT_NAME = "Align Using Last Move Direction";
    var LABEL_PREFIX = "ET_DirectionWatch_";

    if (app.documents.length === 0) {
        alert("Open a document first.", SCRIPT_NAME);
        return;
    }

    if (app.selection.length === 0) {
        alert("Select one or more page items first.", SCRIPT_NAME);
        return;
    }

    var direction = app.extractLabel(LABEL_PREFIX + "direction");

    if (!direction) {
        alert(
            "No movement direction has been recorded yet.\r\r" +
            "Restart InDesign so the startup watcher loads, then select and nudge/move the object before running this script.",
            SCRIPT_NAME
        );
        return;
    }

    app.doScript(
        function () {
            var items = app.selection;

            for (var i = 0; i < items.length; i++) {
                alignItemUsingDirection(items[i], direction, SCRIPT_NAME);
            }
        },
        ScriptLanguage.JAVASCRIPT,
        undefined,
        UndoModes.ENTIRE_SCRIPT,
        SCRIPT_NAME
    );
}());

function alignItemUsingDirection(item, direction, scriptName) {
    if (!item || !item.isValid || !hasBounds(item)) {
        return;
    }

    var page = item.parentPage;

    if (!page || !page.isValid) {
        alert("One selected item is not on a page.", scriptName);
        return;
    }

    var guides = getPageAndSpreadGuides(page);

    if (guides.length === 0) {
        alert("No guides found on this page or spread.", scriptName);
        return;
    }

    var gb = item.geometricBounds;
    var target = getNearestGuideInDirection(guides, gb, direction);

    if (target === null) {
        alert("No guide found in the recorded direction: " + direction, scriptName);
        return;
    }

    if (direction === "left" || direction === "right") {
        item.move(undefined, [target.delta, 0]);
    }
    else {
        item.move(undefined, [0, target.delta]);
    }
}

function getNearestGuideInDirection(guides, bounds, direction) {
    var edge;
    var orientation;
    var best = null;

    if (direction === "left") {
        edge = bounds[1];
        orientation = HorizontalOrVertical.VERTICAL;
    }
    else if (direction === "right") {
        edge = bounds[3];
        orientation = HorizontalOrVertical.VERTICAL;
    }
    else if (direction === "up") {
        edge = bounds[0];
        orientation = HorizontalOrVertical.HORIZONTAL;
    }
    else if (direction === "down") {
        edge = bounds[2];
        orientation = HorizontalOrVertical.HORIZONTAL;
    }
    else {
        return null;
    }

    for (var i = 0; i < guides.length; i++) {
        if (!guides[i].isValid || guides[i].orientation !== orientation) {
            continue;
        }

        var delta = guides[i].location - edge;

        if (direction === "left" && delta > 0) {
            continue;
        }

        if (direction === "right" && delta < 0) {
            continue;
        }

        if (direction === "up" && delta > 0) {
            continue;
        }

        if (direction === "down" && delta < 0) {
            continue;
        }

        if (best === null || Math.abs(delta) < Math.abs(best.delta)) {
            best = { delta: delta };
        }
    }

    return best;
}

function getPageAndSpreadGuides(page) {
    var result = [];
    var i;

    for (i = 0; i < page.guides.length; i++) {
        result.push(page.guides[i]);
    }

    if (page.parent && page.parent.isValid && page.parent.guides) {
        for (i = 0; i < page.parent.guides.length; i++) {
            result.push(page.parent.guides[i]);
        }
    }

    return result;
}

function hasBounds(item) {
    try {
        var gb = item.geometricBounds;
        return gb && gb.length === 4;
    }
    catch (_) {
        return false;
    }
}

When you nudge/move an item it’s recorded silently - then run the script and it moves all

So you just have to nudge or move left/right/up/down and it moves in that direction then run the script - I’m finding the fastest