phoenixcord_sdk/

plugin.rs

/*
 * PhoenixCord, a Discord client mod
 * Copyright (c) 2026 Leclowndu93150 and contributors
 * SPDX-License-Identifier: GPL-3.0-or-later
 */

use crate::types::{
    Badge, ChatBarButton, ChatBarContext, Element, Event, MemberContext, MenuItem, MenuTarget,
    Message, OutgoingEdit, OutgoingMessage, PluginInfo, PopoverButton, ProfileContext,
    SendDecision, Style,
};

/// A PhoenixCord plugin.
///
/// The host creates the plugin with [`Default`] when it is enabled and drops it when it is
/// disabled. Every hook has an empty default, so implement only the hooks listed in
/// [`PluginInfo::hooks`]. The meaning of each hook is documented on the matching function of the
/// `plugin` interface in `phoenixcord.wit`.
pub trait Plugin: Default + 'static {
    /// Static metadata, read once when the plugin is loaded.
    fn info() -> PluginInfo;

    fn start(&mut self) {}

    fn stop(&mut self) {}

    fn on_event(&mut self, _event: Event) {}

    fn pre_send(&mut self, _message: OutgoingMessage) -> SendDecision {
        SendDecision::Keep
    }

    fn pre_edit(&mut self, _edit: OutgoingEdit) -> SendDecision {
        SendDecision::Keep
    }

    fn message_accessories(&mut self, _message: Message) -> Vec<Element> {
        Vec::new()
    }

    fn message_decorations(&mut self, _message: Message) -> Vec<Element> {
        Vec::new()
    }

    fn message_popover_buttons(&mut self, _message: Message) -> Vec<PopoverButton> {
        Vec::new()
    }

    fn chat_bar_buttons(&mut self, _context: ChatBarContext) -> Vec<ChatBarButton> {
        Vec::new()
    }

    fn context_menu(&mut self, _target: MenuTarget) -> Vec<MenuItem> {
        Vec::new()
    }

    fn profile_sections(&mut self, _context: ProfileContext) -> Vec<Element> {
        Vec::new()
    }

    fn user_badges(&mut self, _context: ProfileContext) -> Vec<Badge> {
        Vec::new()
    }

    fn member_decorations(&mut self, _context: MemberContext) -> Vec<Element> {
        Vec::new()
    }

    fn server_list_elements(&mut self) -> Vec<Element> {
        Vec::new()
    }

    fn settings_panel(&mut self) -> Option<Element> {
        None
    }
}

impl PluginInfo {
    /// Metadata with every optional field empty and the plugin disabled by default. Fill in the
    /// rest with struct update syntax.
    pub fn new(name: &str, description: &str, authors: &[&str]) -> Self {
        Self {
            name: name.to_owned(),
            description: description.to_owned(),
            authors: authors.iter().map(|&author| author.to_owned()).collect(),
            tags: Vec::new(),
            dependencies: Vec::new(),
            enabled_by_default: false,
            required: false,
            settings: Vec::new(),
            commands: Vec::new(),
            hooks: Vec::new(),
            events: Vec::new(),
        }
    }
}

impl Default for Style {
    fn default() -> Self {
        Self {
            direction: None,
            align: None,
            justify: None,
            gap: None,
            padding: None,
            width: None,
            height: None,
            grow: false,
            radius: None,
            background: None,
            foreground: None,
            text_size: None,
            text_weight: None,
        }
    }
}

/// Exports a [`Plugin`] implementation as the component's `plugin` interface. Use it once per
/// plugin crate.
#[macro_export]
macro_rules! plugin {
    ($plugin:ty) => {
        struct PhoenixcordGuest;

        ::std::thread_local! {
            static PHOENIXCORD_INSTANCE: ::std::cell::RefCell<::std::option::Option<$plugin>> =
                const { ::std::cell::RefCell::new(::std::option::Option::None) };
        }

        fn phoenixcord_with<R: ::std::default::Default>(f: impl FnOnce(&mut $plugin) -> R) -> R {
            PHOENIXCORD_INSTANCE.with_borrow_mut(|instance| instance.as_mut().map(f).unwrap_or_default())
        }

        impl $crate::Guest for PhoenixcordGuest {
            fn info() -> $crate::types::PluginInfo {
                <$plugin as $crate::Plugin>::info()
            }

            fn start() {
                PHOENIXCORD_INSTANCE.with_borrow_mut(|instance| {
                    $crate::Plugin::start(instance.insert(<$plugin>::default()))
                });
            }

            fn stop() {
                if let ::std::option::Option::Some(mut plugin) =
                    PHOENIXCORD_INSTANCE.with_borrow_mut(::std::option::Option::take)
                {
                    $crate::Plugin::stop(&mut plugin);
                }
            }

            fn on_event(event: $crate::types::Event) {
                phoenixcord_with(|plugin| $crate::Plugin::on_event(plugin, event))
            }

            fn pre_send(message: $crate::types::OutgoingMessage) -> $crate::types::SendDecision {
                PHOENIXCORD_INSTANCE.with_borrow_mut(|instance| match instance.as_mut() {
                    ::std::option::Option::Some(plugin) => $crate::Plugin::pre_send(plugin, message),
                    ::std::option::Option::None => $crate::types::SendDecision::Keep,
                })
            }

            fn pre_edit(edit: $crate::types::OutgoingEdit) -> $crate::types::SendDecision {
                PHOENIXCORD_INSTANCE.with_borrow_mut(|instance| match instance.as_mut() {
                    ::std::option::Option::Some(plugin) => $crate::Plugin::pre_edit(plugin, edit),
                    ::std::option::Option::None => $crate::types::SendDecision::Keep,
                })
            }

            fn message_accessories(message: $crate::types::Message) -> ::std::vec::Vec<$crate::types::Element> {
                phoenixcord_with(|plugin| $crate::Plugin::message_accessories(plugin, message))
            }

            fn message_decorations(message: $crate::types::Message) -> ::std::vec::Vec<$crate::types::Element> {
                phoenixcord_with(|plugin| $crate::Plugin::message_decorations(plugin, message))
            }

            fn message_popover_buttons(message: $crate::types::Message) -> ::std::vec::Vec<$crate::types::PopoverButton> {
                phoenixcord_with(|plugin| $crate::Plugin::message_popover_buttons(plugin, message))
            }

            fn chat_bar_buttons(context: $crate::types::ChatBarContext) -> ::std::vec::Vec<$crate::types::ChatBarButton> {
                phoenixcord_with(|plugin| $crate::Plugin::chat_bar_buttons(plugin, context))
            }

            fn context_menu(target: $crate::types::MenuTarget) -> ::std::vec::Vec<$crate::types::MenuItem> {
                phoenixcord_with(|plugin| $crate::Plugin::context_menu(plugin, target))
            }

            fn profile_sections(context: $crate::types::ProfileContext) -> ::std::vec::Vec<$crate::types::Element> {
                phoenixcord_with(|plugin| $crate::Plugin::profile_sections(plugin, context))
            }

            fn user_badges(context: $crate::types::ProfileContext) -> ::std::vec::Vec<$crate::types::Badge> {
                phoenixcord_with(|plugin| $crate::Plugin::user_badges(plugin, context))
            }

            fn member_decorations(context: $crate::types::MemberContext) -> ::std::vec::Vec<$crate::types::Element> {
                phoenixcord_with(|plugin| $crate::Plugin::member_decorations(plugin, context))
            }

            fn server_list_elements() -> ::std::vec::Vec<$crate::types::Element> {
                phoenixcord_with($crate::Plugin::server_list_elements)
            }

            fn settings_panel() -> ::std::option::Option<$crate::types::Element> {
                phoenixcord_with($crate::Plugin::settings_panel)
            }
        }

        $crate::export!(PhoenixcordGuest with_types_in $crate);
    };
}