Question about scripting for Finder App

While you're waiting...

@Chad and I got to talking a while back about a Secret Sonics podcast you were on, where you were talking about listening to short bursts of audio, we thought the concept was interesting and so I sent him this script. I thought you may dig it.

const burstLengthInMilliseconds = 80;

/**
 * Play a short burst of the Pro Tools timeline with burst length in milliseconds
 * @param{Object} obj
 * @param{Number} obj.burstLength
 */
function playMicroBurstInMilliseconds({ burstLength }) {
    const proTools = sf.ui.proTools;
    const mainWindow = proTools.mainWindow;
    mainWindow.invalidate();
    const transportViewCluster = mainWindow.transportViewCluster;
    const transportButtons = transportViewCluster.transportButtons;
    const { playButton, stopButton } = transportButtons;

    // Ensure the Transport controls are visible
    proTools.transportEnsureCluster();

    const isPlaying = proTools.invalidate().isPlaying;

    // If protools is playing, click stop button
    if (isPlaying) stopButton.elementClick();

    // Click play button
    playButton.elementClick();

    // Wait for burst length
    sf.wait({ intervalMs: burstLength });

    // Click Stop button
    stopButton.elementClick();
}

playMicroBurstInMilliseconds({
    burstLength: burstLengthInMilliseconds,
});

Ah yes... Having to babysit defeats the purpose.

I've not had a chance to test this with large audio files but give this updated version a go. This one asks all the questions up front.

const MIXES_FOLDER_NAME = "_MIXES";
const STEMS_FOLDER_NAME = "_STEMS";
const MIXES_DELIVERY_FOLDER_NAME = "_MIX DELIVERY";

function promptForApprovedVersionNumber(songName) {
    return sf.interaction.displayDialog({
        buttons: ["Ok", "Cancel"],
        cancelButton: "Cancel",
        prompt: `What mix version is approved for the following track...\n\n${songName}`,
        defaultAnswer: "",
        defaultButton: "Ok",
        onCancel: "Abort",
    }).text;
}

function zipDirectoryWithProgress({ sourcePath, archivePath }) {
    sf.file.zipDirectory({
        sourcePath,
        archivePath,
        onProgress: progressMessage => {
            let percentageComplete = (progressMessage['progress'] * 100).toFixed(0);
            log(`Processing: ${percentageComplete} %`);
        },
        progressIntervalMs: 500
    });
}

function copyFiles({ songName, mixesFolderPath, stemsFolderPath, approvedVersionNumber, songDestinationFolder }) {
    log(`Copying Mixes for ${songName}`);

    // Create song destination Folder
    sf.file.directoryCreate({ path: songDestinationFolder });

    // Filter the MIXES folder paths by the approved mix version number
    const approvedMixFilePaths = sf.file.directoryGetFiles({ path: mixesFolderPath }).paths
        .filter(path => path.includes(approvedVersionNumber));

    approvedMixFilePaths.forEach(sourcePath => {
        const fileName = sourcePath.split("/").slice(-1).join("/");
        const destinationPath = `${songDestinationFolder}/${fileName}`;

        // Copy File to destination if the file does not exist there already.
        if (!sf.file.exists({ path: destinationPath }).exists) {
            sf.file.copy({ sourcePath, destinationPath });
        }
    });

    // Filter the STEM Folder paths by the approved version number
    const approvedStemFolderPaths = sf.file.directoryGetDirectories({ path: stemsFolderPath }).paths
        .filter(path => path.includes(approvedVersionNumber));

    log(`Copying Stems for ${songName}`);

    approvedStemFolderPaths.forEach(sourcePath => {
        const fileName = sourcePath.split("/").slice(-1).join("/");
        const destinationPath = `${songDestinationFolder}/${fileName}`;

        // Copy the song Stems Folder if the folder does not exist there already.
        if (!sf.file.directoryExists({ path: destinationPath }).exists) {
            sf.file.copy({ sourcePath, destinationPath });
        }
    });

    log(`Finished copying Mixes and Stems for ${songName}`);
}

function main() {
    // Get the selected folder paths from the finder and sort them
    const selectedFolderPaths = sf.ui.finder.selectedPaths.sort((a, b) => {
        const songNumberA = parseInt(a.match(/\/(\d{2}) /)[1], 10);
        const songNumberB = parseInt(b.match(/\/(\d{2}) /)[1], 10);
        return songNumberA - songNumberB;
    });

    // Convert the first folder path into an array
    const folderPathArray = selectedFolderPaths[0].split("/").filter(Boolean);

    const artistName = folderPathArray.slice(-2, -1).join("/");

    const rootDestinationFolderPath = `${folderPathArray.slice(0, -1).join("/")}`;

    const deliverablesToProcess = [];

    selectedFolderPaths.forEach(sourcePath => {
        const mixesFolderPath = `${sourcePath}${MIXES_FOLDER_NAME}/`;
        const stemsFolderPath = `${sourcePath}${STEMS_FOLDER_NAME}/`;

        // Get the song name based on the song folder name removing the numbers and spaces at the beginning of the name.
        const songName = sourcePath.split("/").filter(Boolean)[sourcePath.split("/").filter(Boolean).length - 1].replace(/^(\d+\s+)/, '');

        // Ask for approved mix number
        const approvedVersionNumber = promptForApprovedVersionNumber(songName);

        // Make the song destination Folder path
        const songDestinationFolder = `${rootDestinationFolderPath}/${MIXES_DELIVERY_FOLDER_NAME}/${songName}`;

        // Copy Mixes to "_MIX DELIVERY/SONG NAME/"
        deliverablesToProcess.push({
            songName,
            mixesFolderPath,
            stemsFolderPath,
            approvedVersionNumber,
            songDestinationFolder
        });
    });

    // Ask to Zip? YES OR NO
    const doZipFolder = sf.interaction.displayDialog({
        buttons: ["No", "Yes"],
        defaultButton: "Yes",
        prompt: `Would you like to zip the Destination Folder?`,
        onCancel: "Abort",
    }).button;

    // Create the "_MIX DELIVERY" directory if it does not exist
    sf.file.directoryCreate({ path: `${rootDestinationFolderPath}/${MIXES_DELIVERY_FOLDER_NAME}` });

    // Copy All Mixes
    deliverablesToProcess.forEach(song => {
        copyFiles({
            songName: song.songName,
            mixesFolderPath: song.mixesFolderPath,
            stemsFolderPath: song.stemsFolderPath,
            approvedVersionNumber: song.approvedVersionNumber,
            songDestinationFolder: song.songDestinationFolder
        });
    });

    if (doZipFolder === "Yes") {
        // Zip Destination Folder
        zipDirectoryWithProgress({
            sourcePath: `${rootDestinationFolderPath}/${MIXES_DELIVERY_FOLDER_NAME}`,
            archivePath: `${rootDestinationFolderPath}/${MIXES_DELIVERY_FOLDER_NAME}_${artistName}.zip`
        });

        // Display message to say the files have been zipped.
        sf.interaction.displayDialog({
            prompt: `The Mixes and Stems for "${artistName}" have been Zipped!`
        });
    }

    // Open and select the Zip file in the finder.
    sf.file.open({ path: rootDestinationFolderPath });
    sf.ui.finder.appActivate();
}

main();

Rock on!