vlibras-player-webjs/dist/cjs/adapters/frameworks/react/hooks/useVLibras.js

Biblioteca JavaScript moderna para integração do VLibras Player com React, Vue, Angular e vanilla JS

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.useVLibras = useVLibras;
const react_1 = require("react");
/**
 * Hook React para gerenciar o VLibras Player
 * Gerencia estado, lifecycle e fornece API simplificada
 */
function useVLibras(options = {}) {
    const [player, setPlayer] = (0, react_1.useState)(null);
    const [isLoaded, setIsLoaded] = (0, react_1.useState)(false);
    const [isPlaying, setIsPlaying] = (0, react_1.useState)(false);
    const [error, setError] = (0, react_1.useState)(null);
    (0, react_1.useEffect)(() => {
        let mounted = true;
        async function initPlayer() {
            try {
                // Import usando caminho relativo correto
                const playerModule = await Promise.resolve().then(() => __importStar(require('../../../../core/player/VLibrasPlayer')));
                const VLibrasPlayer = playerModule.VLibrasPlayer;
                if (!mounted)
                    return;
                const playerInstance = new VLibrasPlayer({
                    targetPath: options.targetPath || '/assets/vlibras',
                    theme: options.theme || 'auto',
                    debug: options.debug || false,
                    autoplay: options.autoplay || false
                });
                setPlayer(playerInstance);
                setIsLoaded(true);
            }
            catch (err) {
                if (mounted) {
                    setError(err instanceof Error ? err.message : 'Failed to initialize VLibras Player');
                }
            }
        }
        if (options.autoInit !== false) {
            initPlayer();
        }
        return () => {
            mounted = false;
        };
    }, [options.targetPath, options.theme, options.debug, options.autoplay, options.autoInit]);
    // Cleanup quando componente desmonta
    (0, react_1.useEffect)(() => {
        return () => {
            if (player) {
                try {
                    player.destroy();
                }
                catch (error) {
                    console.error('Error during player cleanup:', error);
                }
            }
        };
    }, [player]);
    // Handlers com error handling
    const translate = async (text) => {
        if (!player)
            throw new Error('Player not initialized');
        try {
            await player.translateAsync(text);
            setIsPlaying(true);
        }
        catch (err) {
            setError(err instanceof Error ? err.message : 'Translation failed');
            throw err;
        }
    };
    const play = async () => {
        if (!player)
            throw new Error('Player not initialized');
        try {
            await player.playAsync();
            setIsPlaying(true);
        }
        catch (err) {
            setError(err instanceof Error ? err.message : 'Play failed');
            throw err;
        }
    };
    const pause = async () => {
        if (!player)
            throw new Error('Player not initialized');
        try {
            player.pause();
            setIsPlaying(false);
        }
        catch (err) {
            setError(err instanceof Error ? err.message : 'Pause failed');
            throw err;
        }
    };
    const stop = async () => {
        if (!player)
            throw new Error('Player not initialized');
        try {
            player.stop();
            setIsPlaying(false);
        }
        catch (err) {
            setError(err instanceof Error ? err.message : 'Stop failed');
            throw err;
        }
    };
    const destroy = async () => {
        if (!player)
            return;
        try {
            player.destroy();
            setPlayer(null);
            setIsLoaded(false);
            setIsPlaying(false);
        }
        catch (err) {
            setError(err instanceof Error ? err.message : 'Destroy failed');
            throw err;
        }
    };
    return {
        player,
        isLoaded,
        isPlaying,
        error,
        translate,
        play,
        pause,
        stop,
        destroy
    };
}
//# sourceMappingURL=useVLibras.js.map