Trim Fader Across Highlighted Session

So... this turned out to be fairly complex, because there's a lot of setup that needs to be made correctly.
The script needs to set up:

• Ensure automation window is open
• Enable preview
• Enable volume automation
• Set the track to "touch trim" mode
• Ensure track output window is open

Before actually making the change and then writing the automation, and then restoring any settings that it temporarily changed.

The current script also assumes that you have automation warning dialogs ON - as this is the recommended setting when working in SF (since SF then monitors and ensures that you don't accidentally overwrite the whole session).

Here it goes:

/**@param {{
     track: AxPtTrackHeader,
     automationMode?: string,
     automationTrim?: boolean,
     enableVolumeAuto?: boolean,
     enablePreview?: boolean,
     action: () => void,
}} args */
const withAutomationMode = (args) => {
    const {
     track, automationMode, automationTrim, enableVolumeAuto, enablePreview, action,
} = args;

    if (!track || !track.exists) throw `Track is required`;

    //Define reusable funcs to query the state before/after
    const isAutoWindowOpen = () => sf.ui.proTools.automationWindow.invalidate().exists;
    const isAutoVolumeEnabled = () => sf.ui.proTools.automationWindow.enableVolumeAutoButton.value.invalidate().value === "Selected";
    const isAutoPreviewEnabled = () => (sf.ui.proTools.automationWindow.previewButton.value.invalidate().value === "Selected");
    const getTrackAutomationMode = () => track.automationModeButton.value.invalidate().value.replace(/trim/g, '').trim();
    const isTrackAutomationTrim = () => (track.automationModeButton.value.invalidate().value + '').includes('trim');

    let initialState = {
        automationMode: undefined,
        automationTrim: undefined,
        autoWindowOpen: undefined,
        autoVolumeEnabled: undefined,
        autoPreviewEnabled: undefined,
    };

    try {
        //Grab initial state
        initialState.automationMode = getTrackAutomationMode();
        initialState.automationTrim = isTrackAutomationTrim();
        initialState.autoWindowOpen = isAutoWindowOpen();

        //Ensure automation window is open
        if (!initialState.autoWindowOpen)
            sf.ui.proTools.automationWindowRequireOpenAutomationWindow({}, `Couldn't open automation window`);

        //Complete the initialState, now that the automation window is ensured to be open
        initialState.autoVolumeEnabled = isAutoVolumeEnabled();
        initialState.autoPreviewEnabled = isAutoPreviewEnabled();

        //Select the track - TODO: This state change is currently not restored
        track.trackSelect({}, `Couldn't select track ${track.normalizedTrackName}`);

        //Ensure track is in the proper automation mode
        track.automationModeSet({ automationModeName: automationMode, trackTargetMode: 'SelectedTracks' }, `Couldn't select automation mode "${automationMode}" for track`);
        if (automationTrim !== undefined) {
            if (initialState.automationTrim !== automationTrim)
                track.automationModeSet({ automationModeName: 'trim', trackTargetMode: 'SelectedTracks' }, `Couldn't select automation mode "trim" for track`);
        }

        //Enable/disable volume auto
        if (enableVolumeAuto !== undefined && initialState.autoVolumeEnabled !== enableVolumeAuto)
            sf.ui.proTools.automationWindow.enableVolumeAutoButton.elementClick();

        //Enable/disable preview
        if (enablePreview !== undefined)
            sf.ui.proTools.automationPreview({ targetValue: enablePreview ? 'Enable' : 'Disable' });

        //Perform whatever it is you want to happen
        try {

            action();

        } catch (err) {
            throw { inner: err };
        }

    } catch (err) {

        //Errors happening inside the action shouldn't be wrapped by us, so re-throw them directly
        if (err.inner) throw err.inner;

        throw `Error setting up automation.\n${err}`;

    } finally {

        //Restore initial state, ignoring potential errors

        if (initialState.automationMode !== undefined && initialState.automationMode !== getTrackAutomationMode())
            track.automationModeSet({ automationModeName: initialState.automationMode, onError: 'Continue' });

        if (initialState.automationTrim !== undefined && initialState.automationTrim !== isTrackAutomationTrim())
            track.automationModeSet({ automationModeName: 'trim', trackTargetMode: 'SelectedTracks', onError: 'Continue' });

        if (initialState.autoPreviewEnabled !== undefined && initialState.autoPreviewEnabled !== isAutoPreviewEnabled())
            sf.ui.proTools.automationPreview({ targetValue: 'Toggle', onError: 'Continue' });

        if (initialState.autoVolumeEnabled !== undefined && initialState.autoVolumeEnabled !== isAutoVolumeEnabled())
            sf.ui.proTools.automationWindow.enableVolumeAutoButton.elementClick({ onError: 'Continue' });

        if (initialState.autoWindowOpen === false)
            sf.ui.proTools.automationWindow.windowClose({ onError: 'Continue' });
    }
}

/**@param {{
    track: AxPtTrackHeader,
    action: (AxWindow) => void,
}} args */
function withTrackOutput(args) {
    const { track, action } = args;

    //Define reusable state funcs
    function getOutputWin() {
        return sf.ui.proTools.floatingWindows.whoseTitle.is('').filter(w => {
            let trackSel = w.children.whoseTitle.startsWith('Track selector').first;
            if (!trackSel.exists) return false;
            return trackSel.value.value === track.normalizedTrackName;
        })[0];
    }

    let initialState = {
        outputOpen: undefined,
    };

    try {
        let outputWin = getOutputWin();
        initialState.outputOpen = !!outputWin;

        if (!initialState.outputOpen) {
            track.trackOutputToggleShow({}, `Couldn't open track output window.\nMake sure you're displaying track I/O`);
            sf.waitFor({
                callback: () => {
                    outputWin = getOutputWin();
                    return !!outputWin;
                },
                timeout: 2000,
            }, `Track output window didn't open`);
        }

        try {
            action(outputWin);
        } catch (err) {
            throw { inner: err };
        }

    } catch (err) {

        //Errors happening inside the action shouldn't be wrapped by us, so re-throw them directly
        if (err.inner) throw err.inner;

        throw `${err}`;

    } finally {

        //Restore initial state, ignoring potential errors

        if (initialState.outputOpen === false)
            track.trackOutputToggleShow({ onError: 'Continue' });

    }

}

/**@param {{
    track: AxPtTrackHeader,
    amount: number,
    autoConfirmation: boolean
}} args
*/
function trimVolume(args) {
    const { track, amount, autoConfirmation } = args;

    if (!track) throw `Track is required`;
    if (isNaN(Number(amount))) throw `Amount must be a number`;

    /**@param {AxWindow} trackOutputWin */
    function main(trackOutputWin) {
        try {
            let volumeField = trackOutputWin.textFields.whoseTitle.is('Volume Numerical').first;
            if (!volumeField.exists) throw `Couldn't find volume field`;

            volumeField.elementClick({}, `Couldn't focus volume text field`);

            sf.keyboard.type({ text: String(amount) }, `Couldn't type trim amount`);

            sf.keyboard.press({ keys: 'enter' }, `Couln't press enter`);

            sf.wait({ intervalMs: 50 });

            sf.keyboard.press({ keys: 'left' }, `Couldn't update Pro Tools state`); //to update things...

            sf.ui.proTools.automationWindow.writeAutoToSelectionButton.proToolsAutomationClickButton({
                autoConfirmation: autoConfirmation,
            }, `Couldn't write automation to selection.\nEnsure your automation warning dialogs are ${autoConfirmation ? "on" : "off"}`);

        } catch (err) {
            throw `Couldn't trim volume.\n${err}`;
        }
    }

    withAutomationMode({
        track,
        automationMode: 'touch',
        automationTrim: true,
        enableVolumeAuto: true,
        enablePreview: true,
        action: () => {
            withTrackOutput({
                track,
                action: main,
            });
        }
    });
}

function main() {
    let amountStr = prompt(`How much do you want to raise/lower the dB of the selected region?`);
    if (amountStr === undefined || amountStr === '' || String(amountStr).trim() === '') throw 0;

    //To make it easier in countries that use ',' as decimal point
    amountStr = amountStr.replace(/,/g, '.');

    let amount = Number(amountStr);
    if (isNaN(amount)) throw `The amount needs to be a number, for example "-0.5"`;

    trimVolume({
        track: sf.ui.proTools.invalidate().selectedTrack,
        amount,
        autoConfirmation: true,
    });
}

main();