@perspective-dev/viewer 5.5.0 → 5.6.0

package/src/rust/components/column_selector/derived_control.rs

@@ -0,0 +1,229 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ 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). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+use perspective_client::config::ViewConfig;
+use perspective_js::utils::ApiFuture;
+use yew::prelude::*;
+
+// use crate::derived::suggest_name;
+use crate::presentation::Presentation;
+// use crate::queries::fetch_hosted_tables;
+use crate::renderer::Renderer;
+use crate::session::{Session, SessionMetadataRc};
+use crate::tasks::release_derived;
+// use crate::tasks::{can_derive, create_derived, release_derived};
+use crate::utils::{AddListener, PtrEqRc, Subscription, left_click, read_intl_string};
+use crate::workspace::Workspace;
+
+#[derive(Clone, Properties)]
+pub struct DerivedControlProps {
+    pub session: Session,
+    pub renderer: Renderer,
+    pub presentation: Presentation,
+    pub workspace: Workspace,
+    pub metadata: SessionMetadataRc,
+    pub view_config: PtrEqRc<ViewConfig>,
+
+    /// The `Table` this panel is bound to, threaded as a value prop so the
+    /// chain re-renders when the binding changes.
+    pub table: Option<String>,
+}
+
+impl PartialEq for DerivedControlProps {
+    fn eq(&self, other: &Self) -> bool {
+        self.table == other.table
+            && self.metadata == other.metadata
+            && self.view_config == other.view_config
+    }
+}
+
+pub enum DerivedControlMsg {
+    // Create,
+    Release(bool),
+
+    /// Some panel's table binding changed — re-render so the consumer
+    /// count ([`Workspace::derived_consumers`]) gating refreshes.
+    Refresh,
+}
+
+pub struct DerivedControl {
+    /// Keeps the [`Workspace::bindings_changed`] listener attached for this
+    /// component's lifetime.
+    _bindings_sub: Subscription,
+}
+
+impl Component for DerivedControl {
+    type Message = DerivedControlMsg;
+    type Properties = DerivedControlProps;
+
+    fn create(ctx: &Context<Self>) -> Self {
+        let link = ctx.link().clone();
+        let _bindings_sub = ctx
+            .props()
+            .workspace
+            .bindings_changed()
+            .add_listener(move |_| link.send_message(DerivedControlMsg::Refresh));
+
+        Self { _bindings_sub }
+    }
+
+    fn update(&mut self, ctx: &Context<Self>, msg: Self::Message) -> bool {
+        match msg {
+            // DerivedControlMsg::Create => {
+            //     let props = ctx.props().clone();
+            //     ApiFuture::spawn(async move {
+            //         let name = suggest_name(
+            //             &fetch_hosted_tables(&props.workspace)
+            //                 .await
+            //                 .into_iter()
+            //                 .flat_map(|(_, tables)| tables)
+            //                 .collect(),
+            //             &props.view_config,
+            //             &props.table,
+            //         );
+
+            //         create_derived(
+            //             &props.session,
+            //             &props.renderer,
+            //             &props.presentation,
+            //             &props.workspace,
+            //             name,
+            //         )
+            //         .await
+            //     });
+
+            //     false
+            // },
+            DerivedControlMsg::Release(delete) => {
+                let props = ctx.props().clone();
+                let effect = props.workspace.effects().guard();
+                ApiFuture::spawn(async move {
+                    let _effect = effect;
+                    release_derived(
+                        &props.session,
+                        &props.renderer,
+                        &props.presentation,
+                        &props.workspace,
+                        delete,
+                    )
+                    .await
+                });
+
+                false
+            },
+            DerivedControlMsg::Refresh => true,
+        }
+    }
+
+    fn view(&self, ctx: &Context<Self>) -> Html {
+        let props = ctx.props();
+        let workspace = &props.workspace;
+        let bound = props.table.clone().unwrap_or_default();
+        let is_derived = workspace.is_derived(&bound);
+        // let is_pivoted =
+        //     !props.view_config.group_by.is_empty() ||
+        // !props.view_config.split_by.is_empty();
+
+        // let _can_create = is_pivoted && can_derive(&props.session);
+        // if !is_derived && !can_create {
+        //     return html! {};
+        // }
+
+        if !is_derived {
+            return html! {};
+        }
+
+        let is_snapshot = !props.metadata.get_features().is_some_and(|x| x.on_update);
+        let mut chain = workspace.derived_ancestors(&bound);
+        chain.reverse();
+        if is_derived {
+            chain.push(bound.clone());
+            chain.remove(0);
+        }
+
+        let sole_consumer = workspace.derived_consumers(&bound) == 1;
+        let release = left_click(
+            ctx.link()
+                .callback(|event: MouseEvent| DerivedControlMsg::Release(event.shift_key())),
+        );
+
+        // let create = ctx.link().callback(|_| DerivedControlMsg::Create);
+        // let last = chain.len().saturating_sub(1);
+        let viewer = props.presentation.viewer_elem();
+        let intl = |slug: &str, fallback: &str| {
+            read_intl_string(viewer, slug).unwrap_or_else(|| fallback.to_owned())
+        };
+
+        // let _create_title = intl("derive-table-title", "Derive a new table
+        // from this view");
+        let snapshot_title = intl(
+            "derived-snapshot-title",
+            "This data source does not stream - this table's data is fixed at the point it was \
+             derived.",
+        );
+
+        let release_title = if sole_consumer {
+            intl(
+                "derived-release-delete-title",
+                "Back to the parent table - shift-click to delete this one",
+            )
+        } else {
+            intl("derived-release-title", "Back to the parent table")
+        };
+
+        let last = chain.len().saturating_sub(1);
+        let derived_tables = chain.iter().enumerate().map(|(idx, name)| {
+            let is_own = is_derived && idx == last;
+            // let consumers = workspace.derived_consumers(name);
+            let mut close_class = classes!("derived_release");
+            if sole_consumer {
+                close_class.push("shift-alt-icon");
+            }
+
+            let mut level_class = classes!("derived_level");
+            if is_own {
+                level_class.push("is-own");
+            }
+
+            html! {
+                <div class={level_class}>
+                    <div class="derived_label_wrapper">
+                        <span class="derived_icon" />
+                        <span class="derived_label">{ name }</span>
+                    </div>
+                    // if consumers > 1 { <span class="derived_consumers">{ consumers }</span> }
+                    if is_snapshot {
+                        <span class="derived_snapshot" title={snapshot_title.clone()} />
+                    }
+                    if is_own {
+                        <span
+                            class={close_class}
+                            title={release_title.clone()}
+                            onmousedown={release.clone()}
+                        />
+                    } else {
+                        <span class="derived_release disabled" />
+                    }
+                </div>
+            }
+        });
+
+        html! {
+            <div id="derived_stack">
+                // if can_create {
+                //     <div class="derived_create" title={create_title} onmousedown={create} />
+                // }
+                { for derived_tables }
+            </div>
+        }
+    }
+}

package/src/rust/components/column_selector/expr_edit_button.rs

@@ -13,6 +13,7 @@
 use yew::prelude::*;
 
 use super::ColumnSettingsTarget;
+use crate::utils::left_click;
 
 #[derive(PartialEq, Clone, Properties)]
 pub struct ExprEditButtonProps {
@@ -41,10 +42,10 @@ pub struct ExprEditButtonProps {
 /// when pressed, it opens up the expression editor side-panel.
 #[function_component]
 pub fn ExprEditButton(p: &ExprEditButtonProps) -> Html {
-    let onmousedown = yew::use_callback(p.clone(), |_, p| {
+    let onmousedown = left_click(yew::use_callback(p.clone(), |_, p| {
         p.on_open_expr_panel
             .emit(ColumnSettingsTarget::Column(p.name.clone()))
-    });
+    }));
 
     let class = if p.is_disabled {
         "expression-edit-button disabled"

package/src/rust/components/column_selector/filter_column.rs

@@ -410,8 +410,6 @@ impl FilterColumnProps {
         self.metadata.get_column_table_type(filter.column())
     }
 
-    // Get the string value, suitable for the `value` field of a `FilterColumns`'s
-    // `<input>`.
     fn get_filter_input(&self) -> Option<String> {
         let filter_type = self.get_current_filter_type()?;
         match (&filter_type, &self.filter.term()) {

package/src/rust/components/column_selector/inactive_column.rs

@@ -132,9 +132,10 @@ impl Component for InactiveColumn {
             .get_column_table_type(&ctx.props().name)
             .unwrap_or(ColumnType::String);
 
-        let add_column = ctx
-            .link()
-            .callback(|event: MouseEvent| InactiveColumnMsg::ActivateColumn(event.shift_key()));
+        let add_column =
+            left_click(ctx.link().callback(|event: MouseEvent| {
+                InactiveColumnMsg::ActivateColumn(event.shift_key())
+            }));
 
         let ondragend = ctx.props().ondragend.reform(|_| {});
         let ondragstart = ctx.link().callback({
@@ -210,8 +211,6 @@ impl InactiveColumnProps {
         let mut columns = self.view_config.columns.clone();
         let max_cols = self.renderer.metadata().config_column_names.len();
 
-        // Don't treat `None` at the end of the column list as columns, we'll refill
-        // these later
         if let Some(last_filled) = columns.iter().rposition(|x| !x.is_none()) {
             columns.truncate(last_filled + 1);
 

package/src/rust/components/column_selector/pivot_column.rs

@@ -14,9 +14,10 @@ use perspective_client::config::ColumnType;
 use web_sys::*;
 use yew::prelude::*;
 
+use super::expr_edit_button::*;
 use crate::components::dragdrop_list::*;
 use crate::components::type_icon::TypeIcon;
-use crate::presentation::Presentation;
+use crate::presentation::{ColumnSettingsTarget, Presentation};
 use crate::session::*;
 use crate::utils::*;
 
@@ -35,6 +36,14 @@ pub struct PivotColumnProps {
     #[prop_or_default]
     pub metadata: Option<SessionMetadataRc>,
 
+    /// Opens this column's settings, when the host offers them.
+    #[prop_or_default]
+    pub on_open_expr_panel: Option<Callback<ColumnSettingsTarget>>,
+
+    /// Is this column's settings panel open?
+    #[prop_or_default]
+    pub is_editing: bool,
+
     // State
     #[prop_or_default]
     pub opt_session: Option<Session>,
@@ -46,6 +55,8 @@ impl PartialEq for PivotColumnProps {
         self.column == other.column
             && self.action == other.action
             && self.metadata == other.metadata
+            && self.is_editing == other.is_editing
+            && self.on_open_expr_panel.is_some() == other.on_open_expr_panel.is_some()
     }
 }
 
@@ -103,6 +114,15 @@ impl Component for PivotColumn {
                     <span class="drag-handle icon" />
                     <TypeIcon ty={col_type} />
                     <span class="column_name">{ ctx.props().column.clone() }</span>
+                    if let Some(on_open_expr_panel) = &ctx.props().on_open_expr_panel {
+                        <ExprEditButton
+                            name={ctx.props().column.clone()}
+                            {on_open_expr_panel}
+                            is_expression=false
+                            is_disabled=false
+                            is_editing={ctx.props().is_editing}
+                        />
+                    }
                 </div>
             </div>
         }

package/src/rust/components/column_selector/sort_column.rs

@@ -96,9 +96,10 @@ impl Component for SortColumn {
     }
 
     fn view(&self, ctx: &Context<Self>) -> Html {
-        let onclick = ctx
-            .link()
-            .callback(|event: MouseEvent| SortColumnMsg::SortDirClick(event.shift_key()));
+        let onclick = left_click(
+            ctx.link()
+                .callback(|event: MouseEvent| SortColumnMsg::SortDirClick(event.shift_key())),
+        );
 
         let dragstart = Callback::from({
             let event_name = ctx.props().sort.0.to_owned();

package/src/rust/components/column_selector.rs

@@ -15,6 +15,7 @@ mod add_expression_button;
 mod aggregate_selector;
 mod column_selector_column_row;
 mod config_selector;
+mod derived_control;
 mod empty_column;
 mod expr_edit_button;
 mod filter_column;
@@ -37,6 +38,7 @@ use yew::prelude::*;
 use self::active_column::*;
 use self::add_expression_button::AddExpressionButton;
 use self::config_selector::ConfigSelector;
+use self::derived_control::DerivedControl;
 use self::inactive_column::*;
 use crate::components::column_dropdown::{ColumnDropDownElement, ColumnDropDownPortal};
 use crate::config::PluginStaticConfig;
@@ -50,6 +52,7 @@ use crate::session::*;
 use crate::tasks::apply_and_render;
 use crate::ui::{Orientation, ScrollPanel, ScrollPanelItem, SplitPanel};
 use crate::utils::*;
+use crate::workspace::Workspace;
 
 #[derive(Properties)]
 pub struct ColumnSelectorProps {
@@ -83,6 +86,7 @@ pub struct ColumnSelectorProps {
     // State
     pub session: Session,
     pub renderer: Renderer,
+    pub workspace: Workspace,
     pub presentation: Presentation,
 
     /// Fires when this component is resized via the UI.
@@ -391,10 +395,26 @@ impl Component for ColumnSelector {
                 .unwrap_or_default(),
         );
 
+        let derived_control = html_nested! {
+            <ScrollPanelItem key="derived_control" size_hint=0_f64>
+                <DerivedControl
+                    session={ctx.props().session.clone()}
+                    renderer={ctx.props().renderer.clone()}
+                    presentation={ctx.props().presentation.clone()}
+                    workspace={ctx.props().workspace.clone()}
+                    metadata={ctx.props().metadata.clone()}
+                    view_config={ctx.props().view_config.clone()}
+                    table={ctx.props().session.get_table().map(|x| x.get_name().to_owned())}
+                />
+            </ScrollPanelItem>
+        };
+
         let config_selector = html_nested! {
             <ScrollPanelItem key="config_selector" {size_hint}>
                 <ConfigSelector
                     onselect={onselect.clone()}
+                    on_open_expr_panel={ctx.props().on_open_expr_panel.clone()}
+                    selected_column={ctx.props().selected_column.clone()}
                     ondragenter={ctx.link().callback(|()| Redraw)}
                     view_config={ctx.props().view_config.clone()}
                     drag_column={ctx.props().drag_column.clone()}
@@ -570,7 +590,7 @@ impl Component for ColumnSelector {
                     drop={ondrop}
                     on_resize={&ctx.props().on_resize}
                     on_dimensions_reset={&self.on_reset}
-                    children={std::iter::once(config_selector).chain(active_columns).collect::<Vec<_>>()}
+                    children={std::iter::once(derived_control).chain(std::iter::once(config_selector)).chain(active_columns).collect::<Vec<_>>()}
                 />
             </div>
         }];

package/src/rust/components/column_settings_sidebar/save_settings.rs

@@ -12,6 +12,8 @@
 
 use yew::{Callback, Html, Properties, function_component, html};
 
+use crate::utils::left_click;
+
 #[derive(Properties, PartialEq, Clone)]
 pub struct SaveSettingsProps {
     pub save_enabled: bool,
@@ -26,9 +28,9 @@ pub struct SaveSettingsProps {
 
 #[function_component(SaveSettings)]
 pub fn save_settings(props: &SaveSettingsProps) -> Html {
-    let reset = props.on_reset.reform(|_| ());
-    let save = props.on_save.reform(|_| ());
-    let delete = props.on_delete.reform(|_| ());
+    let reset = left_click(props.on_reset.reform(|_| ()));
+    let save = left_click(props.on_save.reform(|_| ()));
+    let delete = left_click(props.on_delete.reform(|_| ()));
     html! {
         <div id="save-settings-wrapper">
             if props.show_danger_zone {

package/src/rust/components/column_settings_sidebar/style_tab.rs

@@ -471,6 +471,7 @@ fn render_leaf(spec: ControlSpec, keys: &[String], ctx: &FieldRenderCtx) -> Opti
             max,
             step,
             include,
+            ..
         } => {
             let current = raw_config
                 .as_ref()

package/src/rust/components/column_settings_sidebar.rs

@@ -34,6 +34,7 @@ use crate::components::expression_editor::ExpressionEditorProps;
 use crate::components::type_icon::TypeIconType;
 use crate::components::window_editor::WindowEditorProps;
 use crate::presentation::{ColumnLocator, ColumnSettingsTab, Presentation};
+use crate::queries::{has_column_config, is_pivot_only_column};
 use crate::renderer::Renderer;
 use crate::session::{Session, SessionMetadataRc};
 use crate::tasks::{
@@ -218,7 +219,9 @@ impl Component for ColumnSettingsPanel {
 
     fn changed(&mut self, ctx: &yew::prelude::Context<Self>, old_props: &Self::Properties) -> bool {
         let next = Initials::of(ctx.props());
-        if ctx.props().selected_column != old_props.selected_column || next != self.initials() {
+        if ctx.props().selected_column != old_props.selected_column
+            || next != Initials::of(old_props)
+        {
             self.reset_to(ctx, next);
         } else {
             self.refresh_derived(ctx);
@@ -541,33 +544,36 @@ impl ColumnSettingsPanel {
         self.save_enabled = changed && valid;
     }
 
-    fn initials(&self) -> Initials {
-        Initials {
-            column_name: self.column_name.clone(),
-            expr: self.initial_expr_value.clone(),
-            header: self.initial_header_value.clone(),
-            window: self.initial_window_value.clone(),
-        }
-    }
-
     fn refresh_derived(&mut self, ctx: &yew::prelude::Context<Self>) {
-        self.maybe_ty = ctx
+        let view_ty = ctx
             .props()
             .metadata
             .locator_view_type(&ctx.props().selected_column);
 
+        self.maybe_ty = match ctx.props().selected_column.name() {
+            Some(name) if is_pivot_only_column(name, &ctx.props().view_config) => {
+                ctx.props().metadata.get_column_table_type(name).or(view_ty)
+            },
+            _ => view_ty,
+        };
+
         self.tabs = {
             let mut tabs = vec![];
             let is_new_expr = ctx.props().selected_column.is_new_expr();
+            let selected_name = ctx
+                .props()
+                .selected_column
+                .name()
+                .map(|x| x.to_string())
+                .unwrap_or_default();
+
             let show_styles = !is_new_expr
-                && ctx.props().renderer.can_render_column_styles()
-                && ctx.props().view_config.columns.contains(&Some(
-                    ctx.props()
-                        .selected_column
-                        .name()
-                        .map(|x| x.to_string())
-                        .unwrap_or_default(),
-                ));
+                && has_column_config(
+                    &selected_name,
+                    &ctx.props().view_config,
+                    &ctx.props().metadata,
+                    &ctx.props().renderer,
+                );
 
             if !is_new_expr && show_styles {
                 tabs.push(ColumnSettingsTab::Style);

package/src/rust/components/debug_panel.rs

@@ -22,13 +22,12 @@ use crate::components::code_editor::CodeEditor;
 use crate::config::*;
 use crate::js::{MimeType, copy_to_clipboard, paste_from_clipboard};
 use crate::presentation::*;
-use crate::queries::fetch_hosted_tables;
 use crate::renderer::*;
 use crate::session::*;
 use crate::utils::*;
 use crate::workspace::Workspace;
 
-#[derive(Clone, PartialEq, Properties)]
+#[derive(Clone, Properties)]
 pub struct DebugPanelProps {
     pub presentation: Presentation,
     pub renderer: Renderer,
@@ -47,9 +46,16 @@ pub struct DebugPanelProps {
     pub on_auto_width: Callback<f64>,
 }
 
+impl PartialEq for DebugPanelProps {
+    fn eq(&self, rhs: &Self) -> bool {
+        self.initial_width == rhs.initial_width
+    }
+}
+
 /// Whether the editor holds text the panel has not successfully applied, read
-/// synchronously by the config-change listeners so a failed apply's own
-/// `view_config_changed` never discards it.
+/// synchronously by the config-change listeners and again when a
+/// [`DebugPanelProps::set_text`] read lands, so neither a failed apply's own
+/// `view_config_changed` nor an in-flight config read discards it.
 type Dirty = Rc<Cell<bool>>;
 
 #[function_component(DebugPanel)]
@@ -72,10 +78,12 @@ pub fn debug_panel(props: &DebugPanelProps) -> Html {
         }
     });
 
-    use_effect_with((expr.setter(), props.clone()), {
+    use_effect_with((), {
         clone!(error, modified, dirty);
-        move |(text, state)| {
-            state.set_text(text.clone());
+        let state = props.clone();
+        let text = expr.setter();
+        move |()| {
+            state.set_text(text.clone(), dirty.clone());
             error.set(None);
             let sub1 = state
                 .renderer
@@ -154,7 +162,7 @@ pub fn debug_panel(props: &DebugPanelProps) -> Html {
         clone!(modified, dirty);
         move |_, (text, error, props)| {
             dirty.set(false);
-            props.set_text(text.clone());
+            props.set_text(text.clone(), dirty.clone());
             error.set(None);
             modified.set(false);
         }
@@ -214,7 +222,9 @@ pub fn debug_panel(props: &DebugPanelProps) -> Html {
 }
 
 impl DebugPanelProps {
-    fn set_text(&self, setter: UseStateSetter<Rc<String>>) {
+    /// Asynchronously read this panel's config into the editor, unless the
+    /// editor has unapplied text by the time the read lands.
+    fn set_text(&self, setter: UseStateSetter<Rc<String>>, dirty: Dirty) {
         let props = self.clone();
         ApiFuture::spawn(async move {
             let config = crate::queries::get_viewer_config(
@@ -222,12 +232,16 @@ impl DebugPanelProps {
                 &props.renderer,
                 &props.presentation,
             )
-            .await?;
+            .await?
+            .map_table(|name| props.workspace.inline_table_ref(&name));
             let json = JsValue::from_serde_ext(&config)?;
             let js_string =
                 js_sys::JSON::stringify_with_replacer_and_space(&json, &JsValue::NULL, &2.into())?;
 
-            setter.set(Rc::new(js_string.as_string().unwrap()));
+            if !dirty.get() {
+                setter.set(Rc::new(js_string.as_string().unwrap()));
+            }
+
             Ok(())
         });
     }
@@ -246,7 +260,7 @@ impl DebugPanelProps {
             }
 
             error.set(None);
-            props.set_text(text.clone());
+            props.set_text(text.clone(), dirty.clone());
             modified.set(false);
         }
     }
@@ -283,21 +297,6 @@ impl DebugPanelProps {
                 },
             };
 
-            if let OptionalUpdate::Update(name) = &config.table {
-                let hosted = fetch_hosted_tables(&props.workspace).await;
-                if !hosted
-                    .iter()
-                    .any(|(_, names)| names.iter().any(|n| n == name))
-                {
-                    fail(
-                        format!("Unknown table \"{name}\""),
-                        locate_key(&source, "table"),
-                    );
-
-                    return Ok(());
-                }
-            }
-
             let active = props.workspace.active_renderer().as_ref() == Some(&props.renderer);
             let result = crate::tasks::restore_panel(
                 &props.session,
@@ -308,6 +307,7 @@ impl DebugPanelProps {
                 config,
                 crate::tasks::RestoreErrors::Suppress,
                 MissingTable::Error,
+                None,
             )
             .await;
 
@@ -316,9 +316,18 @@ impl DebugPanelProps {
                     dirty.set(false);
                     error.set(None);
                     modified.set(false);
-                    props.set_text(text);
+                    props.set_text(text, dirty.clone());
+                },
+                Err(e) => {
+                    let message = format!("{e}");
+                    let position = if message.starts_with("Unknown table") {
+                        locate_key(&source, "table")
+                    } else {
+                        (0, 0)
+                    };
+
+                    fail(message, position)
                 },
-                Err(e) => fail(format!("{e}"), (0, 0)),
             }
 
             Ok(())