@getsolara/solara.voice/index.js

Optional voice functionality for @getsolara/solara.js using @discordjs/voice

const path = require('path');
const fs = require('fs');
const { getVoiceConnection } = require('@discordjs/voice');

function loadVoicePackageFiles(dirPath, fileSuffix = '.js', recursive = false) {
    const results = [];
    if (!fs.existsSync(dirPath)) return results;
    try {
        const items = fs.readdirSync(dirPath, { withFileTypes: true });
        for (const item of items) {
            const fullPath = path.join(dirPath, item.name);
            if (item.isDirectory() && recursive) {
                results.push(...loadVoicePackageFiles(fullPath, fileSuffix, recursive));
            } else if (item.isFile() && item.name.endsWith(fileSuffix)) {
                results.push(fullPath);
            }
        }
    } catch (error) {
        console.error(`Solara.voice FileUtils: Error reading dir ${dirPath}:`, error);
    }
    return results;
}

/**
 * Initializes voice features, sets up a map for voice connections on the client,
 * and registers voice-specific functions.
 * @param {SolaraClient} client - The instance of the SolaraClient.
 * @param {object} voiceConfig - Configuration options for voice (currently unused but for future).
 * @param {boolean} verboseLogging - Whether to enable verbose logging.
 * @returns {boolean} True if initialization seems okay, false otherwise.
 */
function initializeVoiceFeatures(client, voiceConfig, verboseLogging) {
    if (!client || typeof client.addFunction !== 'function') {
        console.error("Solara.voice: Invalid SolaraClient instance provided for initialization.");
        return false;
    }

    client.solaraVoiceConnections = new Map();
    client.solaraAudioPlayers = new Map();
    client.solaraVoiceQueues = new Map();

    client.on('destroy', () => {
        client.solaraVoiceConnections.forEach(conn => conn.destroy());
        client.solaraVoiceConnections.clear();
        client.solaraAudioPlayers.forEach(player => player.stop(true));
        client.solaraAudioPlayers.clear();
        client.solaraVoiceQueues.clear();
    });


    if (verboseLogging) {
        console.log("Solara.voice: Initializing voice features via @getsolara/solara.voice...");
    }

    const funcDir = path.join(__dirname, 'functions');
    let voiceFuncLoadedCount = 0;
    if (fs.existsSync(funcDir)) {
        const functionFiles = loadVoicePackageFiles(funcDir, '.js');
        for (const filePath of functionFiles) {
            try {
                const funcData = require(filePath);
                funcData._filePath = filePath;
                if (client.addFunction(funcData)) {
                    voiceFuncLoadedCount++;
                }
            } catch (funcLoadError) {
                if (funcLoadError.code === 'MODULE_NOT_FOUND') {
                    const missingModule = funcLoadError.message.split("'")[1] || "unknown module";
                    console.warn(`Solara.voice: Skipping function ${path.basename(filePath)} due to missing internal dependency: '${missingModule}'.`);
                } else {
                    console.error(`Solara.voice: Error loading function file ${path.basename(filePath)}:`, funcLoadError);
                }
            }
        }
        if (verboseLogging) {
            console.log(`Solara.voice: Loaded ${voiceFuncLoadedCount} voice-specific functions into the client.`);
        }
    } else if (verboseLogging) {
        console.warn("Solara.voice: 'functions' directory not found in @getsolara/solara.voice package. No voice functions loaded.");
    }
    return true;
}

module.exports = {
    initializeVoiceFeatures
};