tauri-plugin-apple-music-kit-api/dist-js/index.cjs

Tauri plugin for Apple MusicKit integration - TypeScript API bindings

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var core = require('@tauri-apps/api/core');

class MusicKit {
    constructor() {
        this.eventListeners = new Map();
    }
    /**
     * Initialize MusicKit
     */
    async initialize() {
        await core.invoke('plugin:musickit|initialize');
    }
    /**
     * Request authorization to access Apple Music
     */
    async authorize() {
        return await core.invoke('plugin:musickit|authorize');
    }
    /**
     * Unauthorize access to Apple Music
     */
    async unauthorize() {
        return await core.invoke('plugin:musickit|unauthorize');
    }
    /**
     * Get current authorization status
     */
    async getAuthorizationStatus() {
        return await core.invoke('plugin:musickit|getAuthorizationStatus');
    }
    /**
     * Get user token
     */
    async getUserToken() {
        return await core.invoke('plugin:musickit|getUserToken');
    }
    /**
     * Get developer token
     */
    async getDeveloperToken() {
        return await core.invoke('plugin:musickit|getDeveloperToken');
    }
    /**
     * Set developer token
     */
    async setDeveloperToken(token) {
        await core.invoke('plugin:musickit|setDeveloperToken', { token });
    }
    /**
     * Set user token
     */
    async setUserToken(token) {
        await core.invoke('plugin:musickit|setUserToken', { token });
    }
    /**
     * Get storefront information
     */
    async getStorefrontId() {
        return await core.invoke('plugin:musickit|getStorefrontId');
    }
    /**
     * Get current queue
     */
    async getQueue() {
        return await core.invoke('plugin:musickit|getQueue');
    }
    /**
     * Start playback
     */
    async play() {
        await core.invoke('plugin:musickit|play');
    }
    /**
     * Pause playback
     */
    async pause() {
        await core.invoke('plugin:musickit|pause');
    }
    /**
     * Stop playback
     */
    async stop() {
        await core.invoke('plugin:musickit|stop');
    }
    /**
     * Seek to specific time
     */
    async seek(timeInSeconds) {
        await core.invoke('plugin:musickit|seek', { time: timeInSeconds });
    }
    /**
     * Skip to next track
     */
    async next() {
        await core.invoke('plugin:musickit|next');
    }
    /**
     * Skip to previous track
     */
    async previous() {
        await core.invoke('plugin:musickit|previous');
    }
    /**
     * Skip to specific track
     */
    async skipToItem(trackId, startPlaying) {
        await core.invoke('plugin:musickit|skipToItem', { trackId, startPlaying });
    }
    /**
     * Set volume
     */
    async setVolume(volume) {
        await core.invoke('plugin:musickit|setVolume', { volume });
    }
    /**
     * Set the playback queue
     */
    async setQueue(tracks, startPlaying = false, startPosition = 0) {
        return await core.invoke('plugin:musickit|setQueue', { tracks, startPlaying, startPosition });
    }
    /**
     * Update queue
     */
    async updateQueue(tracks) {
        return await core.invoke('plugin:musickit|updateQueue', { tracks });
    }
    /**
     * Insert track at position
     */
    async insertTrackAtPosition(track, position) {
        return await core.invoke('plugin:musickit|insertTrackAtPosition', { track, position });
    }
    /**
     * Insert tracks at position
     */
    async insertTracksAtPosition(tracks, position) {
        return await core.invoke('plugin:musickit|insertTracksAtPosition', { tracks, position });
    }
    /**
     * Remove track from queue
     */
    async removeTrackFromQueue(trackId) {
        return await core.invoke('plugin:musickit|removeTrackFromQueue', { trackId });
    }
    /**
     * Insert track next
     */
    async insertTrackNext(track) {
        return await core.invoke('plugin:musickit|insertTrackNext', { track });
    }
    /**
     * Insert track last
     */
    async insertTrackLast(track) {
        return await core.invoke('plugin:musickit|insertTrackLast', { track });
    }
    /**
     * Append tracks to queue
     */
    async appendTracksToQueue(tracks) {
        return await core.invoke('plugin:musickit|appendTracksToQueue', { tracks });
    }
    /**
     * Listen to MusicKit events
     */
    async addEventListener(event, callback) {
        const unlisten = await core.addPluginListener('musickit', event, (e) => {
            callback(e);
        });
        // Store the unlisten function for cleanup
        if (!this.eventListeners.has(event)) {
            this.eventListeners.set(event, []);
        }
        this.eventListeners.get(event).push(unlisten);
        return unlisten;
    }
    /**
     * Remove all event listeners
     */
    removeAllEventListeners() {
        this.eventListeners.forEach((listeners) => {
            listeners.forEach((listener) => {
                // PluginListener is a function that can be called to remove the listener
                try {
                    listener();
                }
                catch (error) {
                    // Ignore errors when removing listeners
                }
            });
        });
        this.eventListeners.clear();
    }
    /**
     * Check if user has Apple Music subscription
     */
    async hasSubscription() {
        const status = await this.getAuthorizationStatus();
        return status.status === 'authorized';
    }
    /**
     * Get current playback state
     */
    async getPlaybackState() {
        return await core.invoke('plugin:musickit|getPlaybackState');
    }
    /**
     * Get current track
     */
    async getCurrentTrack() {
        return await core.invoke('plugin:musickit|getCurrentTrack');
    }
    /**
     * Check if currently playing
     */
    async isPlaying() {
        const state = await this.getPlaybackState();
        return state.playing;
    }
    /**
     * Check if currently paused
     */
    async isPaused() {
        const state = await this.getPlaybackState();
        return state.paused;
    }
    /**
     * Get current playback time in seconds
     */
    async getCurrentTime() {
        const state = await this.getPlaybackState();
        return state.currentTime;
    }
    /**
     * Get track duration in seconds
     */
    async getDuration() {
        const state = await this.getPlaybackState();
        return state.duration;
    }
    /**
     * Get playback progress as percentage (0-1)
     */
    async getProgress() {
        const state = await this.getPlaybackState();
        return state.progress;
    }
}
// Export singleton instance
const musicKit = new MusicKit();

exports.MusicKit = MusicKit;
exports.default = musicKit;
exports.musicKit = musicKit;