}
    }
}
component ChannelsList {
    in-out property <[string]> channels;
    in-out property <int> active;
    VerticalBox {
        alignment: start;
        spacing: 0;
        preferred-width: 150px;
        Text {
            text: "channels";

        for ch in channels: Text {
            text: "\{ch}";
        }

    in-out property <string> channel_list: "";

    in-out property <[string]> channels <=> chs.channels;
    in-out property <int> active-channel <=> chs.active;

    width: 600px;
    height: 400px;

            VerticalBox {
                alignment: start;
                preferred-width: 150px;
                Text {
                    text: "channels";
                }
                Text {
                    text: "\{root.channel_list}";
                }

            chs := ChannelsList {
                channels: [];
                active: 0;

                preferred-width: 500px;

                    preferred-width: 500px;

            ui.set_channel_list(SharedString::from(&channel_list));

            let channel_strs = channel_list
                .entries
                .into_iter()
                .map(SharedString::from)
                .collect::<Vec<_>>();
            ui.set_channels((&channel_strs[..]).into());
            ui.set_active_channel(i32::try_from(channel_list.active).unwrap_or(-1));

pub fn channel(exe: &std::path::Path, repo: &std::path::Path) -> Result<String, Error> {

pub fn channel(exe: &std::path::Path, repo: &std::path::Path) -> Result<ChannelsList, Error> {

    Ok(String::from_utf8(output.stdout)?)

    parse_channel_output(output.stdout)
}
fn parse_channel_output(output: Vec<u8>) -> Result<ChannelsList, Error> {
    let channels_str = String::from_utf8(output)?;
    let channels_list = channels_str.split('\n').map(|substr| substr.trim()).fold(
        ChannelsList::new(),
        |mut channels_list, ch_str| {
            if ch_str.starts_with("* ") {
                channels_list.active = channels_list.entries.len();
                channels_list.entries.push(ch_str[2..].to_string());
            } else {
                channels_list.entries.push(ch_str.to_string());
            }
            channels_list
        },
    );
    Ok(channels_list)

}
#[derive(Debug)]
pub struct ChannelsList {
    pub(crate) entries: Vec<String>,
    pub(crate) active: usize,

impl ChannelsList {
    pub(crate) fn new() -> Self {
        Self {
            entries: Vec::new(),
            active: usize::MAX,
        }
    }
}