@perspective-dev/viewer 4.0.1 → 4.1.1

package/src/rust/components/{column_settings_sidebar/sidebar.rs → column_settings_sidebar.rs}

@@ -9,77 +9,69 @@
 // ┃ This file is part of the Perspective library, distributed under the terms ┃
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+mod attributes_tab;
+
+mod save_settings;
+mod style_tab;
 
-use std::fmt::Display;
 use std::rc::Rc;
 
 use derivative::Derivative;
 use itertools::Itertools;
 use perspective_client::config::{ColumnType, Expression};
 use perspective_client::utils::PerspectiveResultExt;
-use yew::{Callback, Component, Html, Properties, html};
+use yew::{Callback, Component, Html, Properties, html, props};
 
-use super::attributes_tab::AttributesTabProps;
-use super::style_tab::StyleTabProps;
+use self::attributes_tab::AttributesTabProps;
+use self::style_tab::StyleTabProps;
 use crate::components::column_settings_sidebar::attributes_tab::AttributesTab;
 use crate::components::column_settings_sidebar::save_settings::SaveSettingsProps;
 use crate::components::column_settings_sidebar::style_tab::StyleTab;
 use crate::components::containers::sidebar::Sidebar;
-use crate::components::containers::tab_list::{Tab, TabList};
+use crate::components::containers::tab_list::TabList;
 use crate::components::editable_header::EditableHeaderProps;
 use crate::components::expression_editor::ExpressionEditorProps;
 use crate::components::style::LocalStyle;
 use crate::components::type_icon::TypeIconType;
-use crate::components::viewer::ColumnLocator;
 use crate::custom_events::CustomEvents;
 use crate::model::*;
-use crate::presentation::Presentation;
+use crate::presentation::{ColumnLocator, ColumnSettingsTab, Presentation};
 use crate::renderer::Renderer;
 use crate::session::Session;
-use crate::utils::{AddListener, Subscription};
-use crate::{css, derive_model};
-
-#[derive(Debug, Default, Clone, Copy, PartialEq)]
-pub enum ColumnSettingsTab {
-    #[default]
-    Attributes,
-    Style,
-}
-impl Tab for ColumnSettingsTab {}
-impl Display for ColumnSettingsTab {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_fmt(format_args!("{self:?}"))
-    }
-}
+use crate::utils::*;
+use crate::*;
 
-#[derive(Clone, Properties, Derivative)]
+#[derive(Clone, Derivative, Properties, PerspectiveProperties!)]
 #[derivative(Debug)]
-pub struct ColumnSettingsProps {
-    #[derivative(Debug = "ignore")]
-    pub session: Session,
+pub struct ColumnSettingsPanelProps {
+    pub selected_column: ColumnLocator,
+    pub selected_tab: Option<ColumnSettingsTab>,
+    pub on_close: Callback<()>,
+    pub width_override: Option<i32>,
+    pub on_select_tab: Callback<ColumnSettingsTab>,
+
+    // State
     #[derivative(Debug = "ignore")]
-    pub renderer: Renderer,
+    pub custom_events: CustomEvents,
+
     #[derivative(Debug = "ignore")]
     pub presentation: Presentation,
+
     #[derivative(Debug = "ignore")]
-    pub custom_events: CustomEvents,
+    pub renderer: Renderer,
 
-    pub selected_column: ColumnLocator,
-    pub on_close: Callback<()>,
-    pub width_override: Option<i32>,
-    pub is_active: bool,
+    #[derivative(Debug = "ignore")]
+    pub session: Session,
 }
 
-derive_model!(Session, Renderer, Presentation for ColumnSettingsProps);
-
-impl PartialEq for ColumnSettingsProps {
+impl PartialEq for ColumnSettingsPanelProps {
     fn eq(&self, other: &Self) -> bool {
-        self.selected_column == other.selected_column && self.is_active == other.is_active
+        self.selected_column == other.selected_column && self.selected_tab == other.selected_tab
     }
 }
 
 #[derive(Debug)]
-pub enum ColumnSettingsMsg {
+pub enum ColumnSettingsPanelMsg {
     SetExprValue(Rc<String>),
     SetExprValid(bool),
     SetHeaderValue(Option<String>),
@@ -91,105 +83,38 @@ pub enum ColumnSettingsMsg {
     SessionUpdated(bool),
 }
 
-#[derive(Default, Derivative)]
+#[derive(Derivative)]
 #[derivative(Debug)]
-pub struct ColumnSettingsSidebar {
-    initial_expr_value: Rc<String>,
-    expr_value: Rc<String>,
+pub struct ColumnSettingsPanel {
+    column_name: String,
     expr_valid: bool,
-    initial_header_value: Option<String>,
-    header_value: Option<String>,
+    expr_value: Rc<String>,
     header_valid: bool,
-    selected_tab: ColumnSettingsTab,
-    selected_tab_idx: usize,
-    save_enabled: bool,
-    save_count: u8,
-    reset_enabled: bool,
-    reset_count: u8,
-    column_name: String,
+    header_value: Option<String>,
+    initial_expr_value: Rc<String>,
+    initial_header_value: Option<String>,
     maybe_ty: Option<ColumnType>,
-    tabs: Vec<ColumnSettingsTab>,
-
     on_input: Callback<Rc<String>>,
     on_save: Callback<()>,
     on_validate: Callback<bool>,
+    reset_count: u8,
+    reset_enabled: bool,
+    save_count: u8,
+    save_enabled: bool,
+    tabs: Vec<ColumnSettingsTab>,
 
     #[derivative(Debug = "ignore")]
-    session_sub: Option<Subscription>,
-}
-
-impl ColumnSettingsSidebar {
-    fn save_enabled_effect(&mut self) {
-        let changed = self.expr_value != self.initial_expr_value
-            || self.header_value != self.initial_header_value;
-        let valid = self.expr_valid && self.header_valid;
-        self.save_enabled = changed && valid;
-    }
-
-    fn initialize(&mut self, ctx: &yew::prelude::Context<Self>) {
-        let column_name = ctx
-            .props()
-            .selected_column
-            .name_or_default(&ctx.props().session);
-        let initial_expr_value = ctx
-            .props()
-            .session
-            .metadata()
-            .get_expression_by_alias(&column_name)
-            .unwrap_or_default();
-        let initial_expr_value = Rc::new(initial_expr_value);
-        let initial_header_value =
-            (*initial_expr_value != column_name).then_some(column_name.clone());
-        let maybe_ty = ctx.props().selected_column.view_type(ctx.props().session());
-
-        let tabs = {
-            let mut tabs = vec![];
-            let is_new_expr = ctx.props().selected_column.is_new_expr();
-            let show_styles = !is_new_expr
-                && ctx
-                    .props()
-                    .can_render_column_styles(&column_name)
-                    .unwrap_or_default();
-
-            if !is_new_expr && show_styles {
-                tabs.push(ColumnSettingsTab::Style);
-            }
-
-            if ctx.props().selected_column.is_expr() {
-                tabs.push(ColumnSettingsTab::Attributes);
-            }
-            tabs
-        };
-
-        let on_input = ctx.link().callback(ColumnSettingsMsg::SetExprValue);
-        let on_save = ctx.link().callback(ColumnSettingsMsg::OnSaveAttributes);
-        let on_validate = ctx.link().callback(ColumnSettingsMsg::SetExprValid);
-        *self = Self {
-            column_name,
-            expr_value: initial_expr_value.clone(),
-            initial_expr_value,
-            header_value: initial_header_value.clone(),
-            initial_header_value,
-            maybe_ty,
-            tabs,
-            header_valid: true,
-            on_input,
-            on_save,
-            on_validate,
-            session_sub: self.session_sub.take(),
-            ..*self
-        }
-    }
+    _session_sub: Option<Subscription>,
 }
 
-impl Component for ColumnSettingsSidebar {
-    type Message = ColumnSettingsMsg;
-    type Properties = ColumnSettingsProps;
+impl Component for ColumnSettingsPanel {
+    type Message = ColumnSettingsPanelMsg;
+    type Properties = ColumnSettingsPanelProps;
 
     fn create(ctx: &yew::prelude::Context<Self>) -> Self {
         let session_cb = ctx
             .link()
-            .callback(|(is_update, _)| ColumnSettingsMsg::SessionUpdated(is_update));
+            .callback(|(is_update, _)| ColumnSettingsPanelMsg::SessionUpdated(is_update));
 
         let session_sub = ctx
             .props()
@@ -198,24 +123,32 @@ impl Component for ColumnSettingsSidebar {
             .add_listener(session_cb);
 
         let mut this = Self {
-            session_sub: Some(session_sub),
-            ..Default::default()
+            _session_sub: Some(session_sub),
+            initial_expr_value: Rc::default(),
+            expr_value: Rc::default(),
+            expr_valid: false,
+            initial_header_value: None,
+            header_value: None,
+            header_valid: false,
+            save_enabled: false,
+            save_count: 0,
+            reset_enabled: false,
+            reset_count: 0,
+            column_name: "".to_owned(),
+            maybe_ty: None,
+            tabs: vec![],
+            on_input: Callback::default(),
+            on_save: Callback::default(),
+            on_validate: Callback::default(),
         };
+
         this.initialize(ctx);
         this
     }
 
     fn changed(&mut self, ctx: &yew::prelude::Context<Self>, old_props: &Self::Properties) -> bool {
         if ctx.props() != old_props {
-            let selected_tab = self.selected_tab;
             self.initialize(ctx);
-            self.selected_tab = selected_tab;
-            self.selected_tab_idx = self
-                .tabs
-                .iter()
-                .find_position(|tab| **tab == selected_tab)
-                .map(|(idx, _val)| idx)
-                .unwrap_or_default();
             true
         } else {
             false
@@ -223,8 +156,8 @@ impl Component for ColumnSettingsSidebar {
     }
 
     fn update(&mut self, ctx: &yew::prelude::Context<Self>, msg: Self::Message) -> bool {
-        match msg {
-            ColumnSettingsMsg::SetExprValue(val) => {
+        let result = match msg {
+            ColumnSettingsPanelMsg::SetExprValue(val) => {
                 if self.expr_value != val {
                     self.expr_value = val;
                     self.reset_enabled = true;
@@ -233,12 +166,12 @@ impl Component for ColumnSettingsSidebar {
                     false
                 }
             },
-            ColumnSettingsMsg::SetExprValid(val) => {
+            ColumnSettingsPanelMsg::SetExprValid(val) => {
                 self.expr_valid = val;
                 self.save_enabled_effect();
                 true
             },
-            ColumnSettingsMsg::SetHeaderValue(val) => {
+            ColumnSettingsPanelMsg::SetHeaderValue(val) => {
                 if self.header_value != val {
                     self.header_value = val;
                     self.reset_enabled = true;
@@ -247,18 +180,17 @@ impl Component for ColumnSettingsSidebar {
                     false
                 }
             },
-            ColumnSettingsMsg::SetHeaderValid(val) => {
+            ColumnSettingsPanelMsg::SetHeaderValid(val) => {
                 self.header_valid = val;
                 self.save_enabled_effect();
                 true
             },
-            ColumnSettingsMsg::SetSelectedTab((idx, val)) => {
-                let rerender = self.selected_tab != val || self.selected_tab_idx != idx;
-                self.selected_tab = val;
-                self.selected_tab_idx = idx;
+            ColumnSettingsPanelMsg::SetSelectedTab((_, val)) => {
+                let rerender = ctx.props().selected_tab != Some(val);
+                ctx.props().on_select_tab.emit(val);
                 rerender
             },
-            ColumnSettingsMsg::OnResetAttributes(()) => {
+            ColumnSettingsPanelMsg::OnResetAttributes(()) => {
                 self.header_value.clone_from(&self.initial_header_value);
                 self.expr_value.clone_from(&self.initial_expr_value);
                 self.save_enabled = false;
@@ -266,11 +198,12 @@ impl Component for ColumnSettingsSidebar {
                 self.reset_count += 1;
                 true
             },
-            ColumnSettingsMsg::OnSaveAttributes(()) => {
+            ColumnSettingsPanelMsg::OnSaveAttributes(()) => {
                 let new_expr = Expression::new(
                     self.header_value.clone().map(|s| s.into()),
                     (*(self.expr_value)).clone().into(),
                 );
+
                 match &ctx.props().selected_column {
                     ColumnLocator::Table(_) => {
                         tracing::error!("Tried to save non-expression column!")
@@ -292,7 +225,7 @@ impl Component for ColumnSettingsSidebar {
                 self.save_count += 1;
                 true
             },
-            ColumnSettingsMsg::OnDelete(()) => {
+            ColumnSettingsPanelMsg::OnDelete(()) => {
                 if ctx.props().selected_column.is_saved_expr() {
                     ctx.props().delete_expr(&self.column_name).unwrap_or_log();
                 }
@@ -300,7 +233,7 @@ impl Component for ColumnSettingsSidebar {
                 ctx.props().on_close.emit(());
                 true
             },
-            ColumnSettingsMsg::SessionUpdated(is_update) => {
+            ColumnSettingsPanelMsg::SessionUpdated(is_update) => {
                 if !is_update {
                     self.initialize(ctx);
                     true
@@ -308,48 +241,62 @@ impl Component for ColumnSettingsSidebar {
                     false
                 }
             },
-        }
+        };
+
+        result
     }
 
     fn view(&self, ctx: &yew::prelude::Context<Self>) -> Html {
-        let header_props = EditableHeaderProps {
+        let header_props = props!(EditableHeaderProps {
+            initial_value: self.initial_header_value.clone(),
+            placeholder: self.expr_value.clone(),
+            reset_count: self.reset_count,
+            editable: ctx.props().selected_column.is_expr()
+                && matches!(
+                    ctx.props().selected_tab,
+                    Some(ColumnSettingsTab::Attributes)
+                ),
             icon_type: self
                 .maybe_ty
                 .map(|ty| ty.into())
                 .or(Some(TypeIconType::Expr)),
             on_change: ctx.link().batch_callback(|(value, valid)| {
                 vec![
-                    ColumnSettingsMsg::SetHeaderValue(value),
-                    ColumnSettingsMsg::SetHeaderValid(valid),
+                    ColumnSettingsPanelMsg::SetHeaderValue(value),
+                    ColumnSettingsPanelMsg::SetHeaderValid(valid),
                 ]
             }),
-            editable: ctx.props().selected_column.is_expr()
-                && matches!(self.selected_tab, ColumnSettingsTab::Attributes),
-            initial_value: self.initial_header_value.clone(),
-            placeholder: self.expr_value.clone(),
-            session: ctx.props().session.clone(),
-            reset_count: self.reset_count,
-        };
+            session: &ctx.props().session
+        });
 
-        let expr_editor = ExpressionEditorProps {
-            session: ctx.props().session.clone(),
+        let expr_editor = props!(ExpressionEditorProps {
             on_input: self.on_input.clone(),
             on_save: self.on_save.clone(),
             on_validate: self.on_validate.clone(),
             alias: ctx.props().selected_column.name().cloned(),
             disabled: !ctx.props().selected_column.is_expr(),
             reset_count: self.reset_count,
-        };
+            session: &ctx.props().session
+        });
+
+        let disable_delete = ctx
+            .props()
+            .session
+            .is_locator_active(&ctx.props().selected_column);
 
         let save_section = SaveSettingsProps {
             save_enabled: self.save_enabled,
             reset_enabled: self.reset_enabled,
             is_save: ctx.props().selected_column.name().is_some(),
-            on_reset: ctx.link().callback(ColumnSettingsMsg::OnResetAttributes),
-            on_save: ctx.link().callback(ColumnSettingsMsg::OnSaveAttributes),
-            on_delete: ctx.link().callback(ColumnSettingsMsg::OnDelete),
+            on_reset: ctx
+                .link()
+                .callback(ColumnSettingsPanelMsg::OnResetAttributes),
+            on_save: ctx
+                .link()
+                .callback(ColumnSettingsPanelMsg::OnSaveAttributes),
+            on_delete: ctx.link().callback(ColumnSettingsPanelMsg::OnDelete),
             show_danger_zone: ctx.props().selected_column.is_saved_expr(),
-            disable_delete: ctx.props().is_active,
+            disable_delete,
         };
 
         let attrs_tab = AttributesTabProps {
@@ -357,21 +304,28 @@ impl Component for ColumnSettingsSidebar {
             save_section,
         };
 
-        let style_tab = StyleTabProps {
-            custom_events: ctx.props().custom_events.clone(),
-            session: ctx.props().session.clone(),
-            renderer: ctx.props().renderer.clone(),
-            presentation: ctx.props().presentation.clone(),
+        let style_tab = props!(StyleTabProps {
             ty: self.maybe_ty,
             column_name: self.column_name.clone(),
             group_by_depth: ctx.props().session.get_view_config().group_by.len() as u32,
-        };
+            custom_events: ctx.props().custom_events(),
+            presentation: ctx.props().presentation(),
+            renderer: ctx.props().renderer(),
+            session: ctx.props().session()
+        });
 
         let tab_children = self.tabs.iter().map(|tab| match tab {
             ColumnSettingsTab::Attributes => html! { <AttributesTab ..attrs_tab.clone() /> },
             ColumnSettingsTab::Style => html! { <StyleTab ..style_tab.clone() /> },
         });
 
+        let selected_tab_idx = self
+            .tabs
+            .iter()
+            .find_position(|tab| Some(**tab) == ctx.props().selected_tab)
+            .map(|(idx, _val)| idx)
+            .unwrap_or_default();
+
         html! {
             <>
                 <LocalStyle href={css!("column-settings-panel")} />
@@ -379,13 +333,13 @@ impl Component for ColumnSettingsSidebar {
                     on_close={ctx.props().on_close.clone()}
                     id_prefix="column_settings"
                     width_override={ctx.props().width_override}
-                    selected_tab={self.selected_tab_idx}
+                    selected_tab={selected_tab_idx}
                     {header_props}
                 >
                     <TabList<ColumnSettingsTab>
                         tabs={self.tabs.clone()}
-                        on_tab_change={ctx.link().callback(ColumnSettingsMsg::SetSelectedTab)}
-                        selected_tab={self.selected_tab_idx}
+                        on_tab_change={ctx.link().callback(ColumnSettingsPanelMsg::SetSelectedTab)}
+                        selected_tab={selected_tab_idx}
                     >
                         { for tab_children }
                     </TabList<ColumnSettingsTab>>
@@ -394,3 +348,76 @@ impl Component for ColumnSettingsSidebar {
         }
     }
 }
+
+impl ColumnSettingsPanel {
+    fn save_enabled_effect(&mut self) {
+        let changed = self.expr_value != self.initial_expr_value
+            || self.header_value != self.initial_header_value;
+        let valid = self.expr_valid && self.header_valid;
+        self.save_enabled = changed && valid;
+    }
+
+    fn initialize(&mut self, ctx: &yew::prelude::Context<Self>) {
+        let column_name = ctx
+            .props()
+            .session
+            .locator_name_or_default(&ctx.props().selected_column);
+
+        let initial_expr_value = ctx
+            .props()
+            .session
+            .metadata()
+            .get_expression_by_alias(&column_name)
+            .unwrap_or_default();
+
+        let initial_expr_value = Rc::new(initial_expr_value);
+        let initial_header_value =
+            (*initial_expr_value != column_name).then_some(column_name.clone());
+
+        let maybe_ty = ctx
+            .props()
+            .session()
+            .locator_view_type(&ctx.props().selected_column);
+
+        let tabs = {
+            let mut tabs = vec![];
+            let is_new_expr = ctx.props().selected_column.is_new_expr();
+            let show_styles = !is_new_expr
+                && ctx
+                    .props()
+                    .can_render_column_styles(&column_name)
+                    .unwrap_or_default();
+
+            if !is_new_expr && show_styles {
+                tabs.push(ColumnSettingsTab::Style);
+            }
+
+            if ctx.props().selected_column.is_expr() {
+                tabs.push(ColumnSettingsTab::Attributes);
+            }
+            tabs
+        };
+
+        let on_input = ctx.link().callback(ColumnSettingsPanelMsg::SetExprValue);
+        let on_save = ctx
+            .link()
+            .callback(ColumnSettingsPanelMsg::OnSaveAttributes);
+
+        let on_validate = ctx.link().callback(ColumnSettingsPanelMsg::SetExprValid);
+        *self = Self {
+            column_name,
+            expr_value: initial_expr_value.clone(),
+            initial_expr_value,
+            header_value: initial_header_value.clone(),
+            initial_header_value,
+            maybe_ty,
+            tabs,
+            header_valid: true,
+            on_input,
+            on_save,
+            on_validate,
+            _session_sub: self._session_sub.take(),
+            ..*self
+        }
+    }
+}

package/src/rust/components/containers/dragdrop_list.rs

@@ -21,21 +21,7 @@ use yew::prelude::*;
 use crate::components::column_selector::{EmptyColumn, InPlaceColumn, InvalidColumn};
 use crate::custom_elements::ColumnDropDownElement;
 use crate::dragdrop::*;
-
-/// Must be implemented by `Properties` of children of `DragDropList`, returning
-/// the value a DragDropItem represents.
-pub trait DragDropListItemProps: Properties {
-    type Item: Clone + PartialEq;
-    fn get_item(&self) -> Self::Item;
-}
-
-pub trait DragContext<T> {
-    fn close(index: usize) -> T;
-    fn dragleave() -> T;
-    fn dragenter(index: usize) -> T;
-    fn create(col: InPlaceColumn) -> T;
-    fn is_self_move(effect: DragTarget) -> bool;
-}
+use crate::utils::DragTarget;
 
 #[derive(Properties, Derivative)]
 #[derivative(Clone(bound = ""))]
@@ -227,11 +213,10 @@ where
                     .position(|x| x.1.1.as_ref().unwrap().props.get_item() == *column);
 
                 valid_duplicate_drag = is_duplicate.is_some() && !ctx.props().allow_duplicates;
-                if let Some(duplicate) = is_duplicate
-                    && !is_append
-                    && (!ctx.props().allow_duplicates || is_self_move)
-                {
-                    columns.remove(duplicate);
+                if let Some(duplicate) = is_duplicate {
+                    if !is_append && (!ctx.props().allow_duplicates || is_self_move) {
+                        columns.remove(duplicate);
+                    }
                 }
 
                 // If inserting into the middle of the list, use
@@ -323,3 +308,18 @@ where
         }
     }
 }
+
+/// Must be implemented by `Properties` of children of `DragDropList`, returning
+/// the value a DragDropItem represents.
+pub trait DragDropListItemProps: Properties {
+    type Item: Clone + PartialEq;
+    fn get_item(&self) -> Self::Item;
+}
+
+pub trait DragContext<T> {
+    fn close(index: usize) -> T;
+    fn dragleave() -> T;
+    fn dragenter(index: usize) -> T;
+    fn create(col: InPlaceColumn) -> T;
+    fn is_self_move(effect: DragTarget) -> bool;
+}

package/src/rust/components/containers/dropdown_menu.rs

@@ -20,10 +20,6 @@ use super::select::SelectItem;
 use crate::components::style::LocalStyle;
 use crate::*;
 
-pub type DropDownMenuItem<T> = SelectItem<T>;
-
-pub type DropDownMenuMsg = ();
-
 #[derive(Properties, PartialEq)]
 pub struct DropDownMenuProps<T>
 where
@@ -44,7 +40,7 @@ impl<T> Component for DropDownMenu<T>
 where
     T: Into<Html> + Clone + PartialEq + 'static,
 {
-    type Message = DropDownMenuMsg;
+    type Message = ();
     type Properties = DropDownMenuProps<T>;
 
     fn create(_ctx: &Context<Self>) -> Self {
@@ -76,7 +72,7 @@ where
                     DropDownMenuItem::OptGroup(name, xs) => {
                         html! {
                             <>
-                                <span class="dropdown-group-label">{ name }</span>
+                                <span class="dropdown-group-label">{ name.as_ref() }</span>
                                 <div class="dropdown-group-container">
                                     { xs.iter().map(|x| {
                                     let click = ctx.props().callback.reform({
@@ -102,3 +98,5 @@ where
         html! { <><LocalStyle href={css!("containers/dropdown-menu")} />{ body }</> }
     }
 }
+
+pub type DropDownMenuItem<T> = SelectItem<T>;

package/src/rust/components/containers/mod.rs

@@ -15,14 +15,11 @@
 
 pub mod dragdrop_list;
 pub mod dropdown_menu;
-pub mod kvpair;
 pub mod scroll_panel;
 pub mod scroll_panel_item;
 pub mod select;
 pub mod sidebar;
+pub mod sidebar_close_button;
 pub mod split_panel;
 pub mod tab_list;
 pub mod trap_door_panel;
-
-#[cfg(test)]
-mod tests;