Hide Empty Folder Tracks

Hello @mikkeljm,
Try this,
It will do as you ask the first parent folders, folders inside folders wont work with this code.
Let me know if this is it.

function clickAllGroupSymbol() {
    sf.ui.proTools.groupsEnsureGroupListIsVisible();
    sf.ui.proTools.mainWindow.groupListView.children.whoseRole.is("AXColumn").first
        .children.whoseRole.is("AXRow").first
        .children.whoseRole.is("AXCell").first
        .buttons.first.elementClick();

    sf.ui.proTools.trackDeselectAll();
};

function openAllFolderTracks() {
    sf.ui.proTools.invalidate()

    const selectedTrackHeaders = sf.ui.proTools.selectedTrackHeaders;

    clickAllGroupSymbol();

    sf.ui.proTools.invalidate();


    // Select original Track Selection
    if (selectedTrackHeaders.length > 0) {
        selectedTrackHeaders[0].trackSelect()
        selectedTrackHeaders[0].trackScrollToView()
        sf.ui.proTools.trackSelectByName({ names: selectedTrackHeaders.map(tr => tr.normalizedTrackName) })
    };
};




/**
 * @param {AxPtTrackHeader} track
 */
function getTrackDepth(track) {
    return Math.floor((track.titleButton.frame.x - track.frame.x) / 15);
}

/**
 * @author Christian Scheuer - https://forum.soundflow.org/-1784/how-to-select-specific-type-of-tracks-inside-a-folder
 */
function getTrackFolderStructure() {
    var root = { children: [] };
    var stack = [];
    stack[0] = root;
    var flatList = sf.ui.proTools.visibleTrackHeaders.map(t => ({ track: t, depth: getTrackDepth(t) }));
    for (var i = 0; i < flatList.length; i++) {
        var flatItem = flatList[i];
        var node = {
            name: flatItem.track.normalizedTrackName,
            type: flatItem.track.title.value.match(/ - (.*)$/)[1].trim().replace(/track$/i, '').trim().toLowerCase(),
            track: flatItem.track,
            children: []
        };
        stack[flatItem.depth] = node;
        stack[flatItem.depth - 1].children.push(node);
    }
    return root;
};

function main(callback) {

    const isTrackListVisible = sf.ui.proTools.getMenuItem("View", "Other Displays", "Track List").isMenuChecked
    const selectedTrackHeaders = sf.ui.proTools.selectedTrackHeaders;

    try {
        //Open All folders
        clickAllGroupSymbol();

        callback();

    } catch (err) {
        throw err
    } finally {

        sf.ui.proTools.invalidate();
        // Select original Track Selection
        if (selectedTrackHeaders.length > 0) {
            selectedTrackHeaders[0].trackSelect()
            selectedTrackHeaders[0].trackScrollToView()
            sf.ui.proTools.trackSelectByName({ names: selectedTrackHeaders.map(tr => tr.normalizedTrackName) })
        };

        //Close track list if originaly closed
        if (!isTrackListVisible) sf.ui.proTools.menuClick({ menuPath: ["View", "Other Displays", "Track List"], targetValue: "Disable" })
    };
};


function hideAndMakeInactiveEmptyFolders() {

    sf.ui.proTools.mainWindow.invalidate();

    const root = getTrackFolderStructure();

    const emptyFolders = root.children.filter(track =>
        track.type.endsWith("folder") &&
        track.children.length === 0
    ).map(folder => folder.name)

    sf.ui.proTools.trackSelectByName({ names: emptyFolders });
    sf.ui.proTools.trackHideAndMakeInactiveSelected();
};


main(hideAndMakeInactiveEmptyFolders);

Thanks Samuel.

This did the trick. I love it. Big help.

@samuel_henriques,

With SF 5.10.3 the code for this becomes much simpler.
The PT SDK can now return parentFolder for tracks.
Using this we can get all folder track names, check if it is a parent of any other track and if not, hide/deactivate or delete it.
If a folder is hidden / deleted then the function calls itself again (a recursive function) until the number of tracks in the session hasn't changed.
This will delete or deactivate and hide all empty folders and(!) subfolders:

sf.ui.proTools.appActivateMainWindow();

const getTracks = () => sf.app.proTools.tracks.invalidate().allItems;

function deleteFolder(trackName) {
    sf.app.proTools.selectTracksByName({
        trackNames: [trackName]
    })
    sf.ui.proTools.menuClick({
        menuPath: ["Track", "Delete"]
    })
}

function deactivateFolder(trackName) {
    sf.app.proTools.setTrackInactiveState({
        trackNames: [trackName],
        enabled: true
    })
}

function hideFolderTrack(trackName) {
    sf.app.proTools.setTrackHiddenState({
        trackNames: [trackName],
        enabled: true
    })
}

let deletedOrHiddenFolders = []

let pass = 1
function hideAndDeactivateEmptyFolderTracks() {
    const uid = "hideDeactivateEmptyFolders" + Date.now();

    let tracksInSession = getTracks();
    let inactiveTracksInSession = tracksInSession.filter(t => t.isInactive)

    const folderTracks = tracksInSession.filter(t => t.type.endsWith("Folder")).filter(t => !t.isInactive);
    let folderTrackNames = folderTracks.map(f => f.name);

    folderTrackNames.forEach((folderName, index) => {

        sf.interaction.notify({
            uid,
            title: "Hide and deactivate empty folder tracks",
            message: `${folderName}:Checking for sub-tracks. Pass ${pass}`,
            progress: (index + 1) / folderTrackNames.length,
            keepAliveMs: 500

        })
        // if (getTracks().find(t => t.name == folderName).isInactive) return

        function getSubTracks(folderName) {

            const tracksInFolder = getTracks().filter(t => t.parentFolderName == folderName);
            const tracksInFolderNames = tracksInFolder.map(t => t.name);
            let activeSubTrackCount = 0
            tracksInFolder.forEach(t => {
                if (!t.isInactive) { activeSubTrackCount++; }
            })
            if (activeSubTrackCount == 0) {
                hideFolderTrack(folderName);
                deactivateFolder(folderName);
                deletedOrHiddenFolders.push(folderName)
                return
            }
            if (tracksInFolderNames.length == 1) {

                const subTrack = getTracks().find(t => t.name == tracksInFolderNames[0])
                // if (subTrack.isInactive) getSubTracks(subTrack.name);
                if (subTrack.isInactive ) return;
                if (subTrack.type.endsWith("Folder") && !subTrack.isInactive) {
                    getSubTracks(subTrack.name)
                }
                if (subTrack.type.endsWith("Folder") && subTrack.isInactive) {
                    hideFolderTrack(folderName);
                    deactivateFolder(folderName);
                    deletedOrHiddenFolders.push(folderName)
                    return
                }
            }
            if (tracksInFolderNames.length == 0) {
                hideFolderTrack(folderName);
                deactivateFolder(folderName);
                deletedOrHiddenFolders.push(folderName)
            }
        }
        getSubTracks(folderName)

        // Compare number of inactive tracks in session after deactivating
        // If different run again
    })
    const updatedInactiveTracksCount = getTracks().filter(t => t.isInactive).length
    if (updatedInactiveTracksCount != inactiveTracksInSession.length) {
        pass++
        hideAndDeactivateEmptyFolderTracks();
    }
    // 
    const tracksHiddenAndDeactivatedCount = getTracks().filter(t => t.isInactive).length - inactiveTracksInSession.length

    sf.interaction.notify({
        title: "Hide Empty Folders",
        message: `${tracksHiddenAndDeactivatedCount} folders Hidden and made inactive`
    })
}

function deleteEmptyFolders() {
    let tracksInSession = getTracks();

    const folderTracks = tracksInSession.filter(t => t.type.endsWith("Folder"));
    const folderTrackNames = folderTracks.map(f => f.name);

    folderTrackNames.forEach(folderName => {
        const tracksInFolder = tracksInSession.filter(t => t.parentFolderName == folderName).map(t => t.name);

        if (tracksInFolder.length == 0) {
            deleteFolder(folderName);
            deletedOrHiddenFolders.push(folderName)
        }
    })
    // Compare number of tracks in session after deletion
    // If different run again
    if (tracksInSession.length != getTracks().length) deleteEmptyFolders()

    sf.interaction.notify({
        title: "Delete Empty Folders",
        message: `${deletedOrHiddenFolders.length} folders deleted`
    })
}

function main() {
    const deleteOrHide = sf.interaction.displayDialog({
        prompt: "Delete or deactivate/hide all empty folders?",
        buttons: ["Cancel", "Delete", "Hide"],
        defaultButton: "Hide"
    }).button

    deleteOrHide == "Delete" ? deleteEmptyFolders() : hideAndDeactivateEmptyFolderTracks()
}

main()