@yuneta/gobj-ui 7.25.7 → 7.25.8

package/src/c_yui_schema_editor.js

@@ -206,6 +206,7 @@ let PRIVATE_DATA = {
     pending:        0,      /*  `nodes` requests still in flight  */
     load_error:     "",
     load_round:     0,      /*  which load an answer belongs to: echoed as `round`  */
+    load_keeps_written: false,  /*  the load in flight is not the host's: `written` survives it  */
 
     /*  Where the operator is. The url carries it; these mirror it.  */
     treedb_id:      "",
@@ -458,8 +459,25 @@ function refuse_if_readonly(gobj, event)
  *  schema set of the yuno is here: everything below — the
  *  drawing, the validation, the export — is computed from these
  *  and asks the backend nothing more.
+ *
+ *  THE LOADING SCREEN IS DRAWN, not assumed. ST_LOADING declares
+ *  none of the actions of a screen, so the screen it replaces goes
+ *  and the toolbar stops answering: left up, a click on a card, on
+ *  Back or on the drawing answered "Event NOT DEFINED in state
+ *  ST_LOADING" and was lost (third independent review). A dialog
+ *  left open is answered in ST_LOADING instead (ac_wait_for_the_load).
+ *
+ *  `keep_written`: a load the host did not ask for -- the reconnect,
+ *  a write that turned out done -- keeps what this session wrote.
+ *  Only the host's EV_REFRESH (a Save sends it) forgets it.
+ *
+ *  A load that cannot leave WHOLE did not happen (out of session it
+ *  is not even asked): the records the model was built on are put
+ *  back (emptied, the next write patched them into a model with no
+ *  treedb), the round is spent so a request that did leave is
+ *  stale, and the session back asks again.
  ***************************************************************/
-function request_model(gobj)
+function request_model(gobj, keep_written)
 {
     let priv = gobj.priv;
     let remote = gobj_read_pointer_attr(gobj, "gobj_remote_yuno");
@@ -468,27 +486,41 @@ function request_model(gobj)
         return -1;      /*  not mounted on a transport yet: mt_start retries via EV_TRANSPORT_STATE  */
     }
 
+    let previous = priv.records;
     priv.records = {treedbs: [], topics: [], cols: []};
     priv.load_error = "";
     priv.pending = 0;
     priv.load_round++;
+    priv.load_keeps_written = !!keep_written;
     gobj_change_state(gobj, "ST_LOADING");
-    show_notice(gobj, "loading the schemas");
-
-    for(let topic_name of [T_TREEDBS, T_TOPICS, T_COLS]) {
-        if(remote_command(gobj, "nodes", {
-            topic_name: topic_name,
-            options:    {list_dict: true}
-        }, {round: priv.load_round}) === 0) {
-            priv.pending++;
+    set_busy(gobj, false);
+    render(gobj);
+
+    /*  Out of session nothing is asked: each request would come back
+     *  refused and logged as an ERROR, for a drop that is not one.  */
+    let left = 0;
+    if(transport_in_session(gobj)) {
+        for(let topic_name of [T_TREEDBS, T_TOPICS, T_COLS]) {
+            if(remote_command(gobj, "nodes", {
+                topic_name: topic_name,
+                options:    {list_dict: true}
+            }, {round: priv.load_round}) === 0) {
+                left++;
+            }
         }
     }
-    if(priv.pending === 0) {
+    if(left < 3) {
+        priv.records = previous;
+        priv.load_round++;
+        priv.reload_on_open = true;
         priv.load_error = t("cannot reach the treedb");
-        gobj_change_state(gobj, "ST_IDLE");
-        show_notice(gobj, "cannot reach the treedb");
+        if(priv.model) {
+            yui_shell_show_error(yui_shell_of(gobj), "cannot reach the treedb", {t: t});
+        }
+        end_load(gobj);
         return -1;
     }
+    priv.pending = left;
     return 0;
 }
 
@@ -571,17 +603,23 @@ function build_model(gobj)
  *  From here on, "did this session change it?" has an answer.
  *
  *  Called ONLY when records arrive from the store: that is what a
- *  measurement of "changed since" can be measured against. Both
- *  halves reset together -- a baseline without its `written` is
- *  the same false positive from the other side, since every
- *  version equals a baseline just taken.
+ *  measurement of "changed since" can be measured against.
+ *
+ *  `written` is forgotten only by a load the HOST asked for (its
+ *  EV_REFRESH, which a Save sends). Since M36 a write moves no
+ *  version, so `written` is the draft chip of what this session
+ *  wrote and no longer half of a version measurement: a reload of
+ *  the reconnect, or of a write that turned out done, forgot the
+ *  chips of writes the host had not been told about.
  ***************************************************************/
 function start_measuring(gobj)
 {
     let priv = gobj.priv;
 
     priv.baseline = {};
-    priv.written = {};
+    if(!priv.load_keeps_written) {
+        priv.written = {};
+    }
     priv.host_ids = {};
 
     if(!priv.model) {
@@ -805,12 +843,19 @@ function render_toolbar(gobj)
     let state = gobj_current_state(gobj);
     let readonly = is_readonly(gobj);
     let has_model = !!priv.model;
+    /*  The position can outlive its screen (a load that failed keeps the
+     *  url's; ST_EMPTY has a treedb in the url and none in the model),
+     *  and a button there sends what only a treedb screen declares.  */
+    let on_a_treedb = state !== "ST_IDLE" && state !== "ST_EMPTY";
+    /*  Nothing is legal while the model is in the air: every action is
+     *  computed against it.  */
+    let in_flight = state === "ST_SAVING" || state === "ST_LOADING";
 
     /*----------------------------------------------*
      *  Left: back, then the position as a trail.
      *----------------------------------------------*/
     let $left = [];
-    if(priv.treedb_id) {
+    if(priv.treedb_id && on_a_treedb) {
         $left.push(["button", {class: "SCHEMA_BACK button",
                                type: "button",
                                title: t("back"), "aria-label": t("back"),
@@ -847,7 +892,7 @@ function render_toolbar(gobj)
      *  refused says why when it is pressed.
      *----------------------------------------------*/
     let $right = [];
-    if(priv.treedb_id && has_model) {
+    if(priv.treedb_id && has_model && on_a_treedb) {
         /*  The compass, like every other door to a SCHEMA: the
          *  `hexagon-nodes` it wore is the graph of the DATA.  */
         $right.push(toolbar_button("SCHEMA_DIAGRAM_BTN", "yi-compass-drafting",
@@ -861,7 +906,7 @@ function render_toolbar(gobj)
                 "import", "EV_IMPORT", false));
         }
     }
-    if(priv.topic_name && !readonly && !priv.diagram) {
+    if(priv.topic_name && !readonly && !priv.diagram && on_a_treedb) {
         /*  Only while there IS somewhere to go back to: a drag is a write,
          *  and this is the way back from one. */
         if(undo_order_writes(gobj, current_topic(gobj)).length > 0) {
@@ -871,7 +916,7 @@ function render_toolbar(gobj)
         $right.push(toolbar_button("SCHEMA_ADD_COL_BTN", "yi-plus",
             "new column", "EV_ADD_COLUMN", false));
     }
-    if(priv.treedb_id && !priv.topic_name && !readonly && !priv.diagram) {
+    if(priv.treedb_id && !priv.topic_name && !readonly && !priv.diagram && on_a_treedb) {
         $right.push(toolbar_button("SCHEMA_ADD_TOPIC_BTN", "yi-plus",
             "new topic", "EV_ADD_TOPIC", false));
     }
@@ -894,7 +939,7 @@ function render_toolbar(gobj)
      *  destroyed.  */
     for(let $button of $bar.querySelectorAll("button")) {
         $button.__gobj__ = gobj;
-        if(state === "ST_SAVING") {
+        if(in_flight) {
             $button.disabled = true;
         }
     }
@@ -918,19 +963,25 @@ function render(gobj)
     }
     render_toolbar(gobj);
 
+    /*  A screen with nothing to draw takes the drawing down too: left
+     *  alive, it was only re-shown on the way back -- into a body that
+     *  no longer held it.  */
     if(state === "ST_LOADING") {
         show_notice(gobj, "loading the schemas");
+        destroy_diagram(gobj);
         clear($body);
         return;
     }
     if(state === "ST_IDLE") {
         show_notice(gobj, priv.load_error ? "cannot load the schemas" : "not connected",
             priv.load_error);
+        destroy_diagram(gobj);
         clear($body);
         return;
     }
     if(state === "ST_EMPTY") {
         show_notice(gobj, "this yuno stores no schema");
+        destroy_diagram(gobj);
         clear($body);
         return;
     }
@@ -1471,12 +1522,21 @@ function render_diagram(gobj)
     let $body = $of(gobj, ".SCHEMA_BODY");
     let treedb = current_treedb(gobj);
 
-    if(!$body || !treedb) {
+    if(!$body) {
+        return;
+    }
+    /*  Said on an EMPTY body, as the topics and the columns say it:
+     *  render() clears the body for every screen but this one, and the
+     *  screen before stayed up under the notice, clickable.  */
+    if(!treedb) {
+        destroy_diagram(gobj);
+        clear($body);
         show_notice(gobj, "that treedb is not here any more", priv.treedb_id);
         return;
     }
     if(!gclass_find_by_name("C_YUI_TREEDB_SCHEMA")) {
         log_error(`${gobj_short_name(gobj)}: C_YUI_TREEDB_SCHEMA not registered by the app`);
+        clear($body);
         show_notice(gobj, "the schema drawing is not available");
         return;
     }
@@ -2501,29 +2561,15 @@ function end_writes(gobj, error)
 {
     let priv = gobj.priv;
 
+    let seg = priv.pending_seg;
+
     priv.save_queue = [];
+    priv.pending_seg = null;
     gobj_change_state(gobj, priv.save_return || "ST_TREEDBS");
     priv.save_return = "";
     show_notice(gobj, "");
     set_busy(gobj, false);
 
-    /*  A position that arrived while the write was in flight: applied
-     *  now, so a Back pressed mid-save is not simply lost.  */
-    if(priv.pending_seg !== null) {
-        let seg = priv.pending_seg;
-        priv.pending_seg = null;
-        if(!error) {
-            apply_seg(gobj, seg);
-            if(priv.save_wrote) {
-                gobj_publish_event(gobj, "EV_RECORD_WRITTEN", {
-                    treedb_name: gobj_read_str_attr(gobj, "treedb_name")
-                });
-            }
-            priv.save_wrote = false;
-            return reload_if_owed(gobj);
-        }
-    }
-
     if(error) {
         yui_shell_show_error(yui_shell_of(gobj), error, {t: t});
     }
@@ -2533,8 +2579,18 @@ function end_writes(gobj, error)
         });
     }
     priv.save_wrote = false;
-    render(gobj);
-    publish_check(gobj);
+
+    /*  A position that arrived while the write was in flight: applied
+     *  now, so a Back pressed mid-save is not simply lost -- with an
+     *  error too. The host's url already says it, and a load cut by a
+     *  drop applies it (end_load()): the write kept the old screen, and
+     *  the url and the view disagreed.  */
+    if(seg !== null) {
+        apply_seg(gobj, seg);
+    } else {
+        render(gobj);
+        publish_check(gobj);
+    }
     reload_if_owed(gobj);
     return error ? -1 : 0;
 }
@@ -2556,7 +2612,7 @@ function reload_if_owed(gobj)
         priv.reload_on_open = true;
         return 0;
     }
-    return request_model(gobj);
+    return request_model(gobj, true);
 }
 
 /***************************************************************
@@ -2660,6 +2716,9 @@ function go(gobj, treedb_id, topic_name, diagram, mirror)
 {
     let priv = gobj.priv;
 
+    /*  Moving IS the answer to a position that waited: one left behind
+     *  sent a later load back to it.  */
+    priv.pending_seg = null;
     priv.treedb_id = treedb_id || "";
     priv.topic_name = topic_name || "";
     priv.diagram = !!diagram;
@@ -2857,7 +2916,7 @@ function ac_mt_command_answer(gobj, event, kw, src)
                     `for a write that is over (result ${result}): ignored`);
                 return 0;
             }
-            return late_write_done(gobj, command, topic_name);
+            return late_write_done(gobj, command, topic_name, data);
         }
         if(result < 0) {
             return end_writes(gobj, comment || t("the treedb refused the write"));
@@ -2874,8 +2933,17 @@ function ac_mt_command_answer(gobj, event, kw, src)
                 /*  The treedb wrote it and did not describe it back: ask
                  *  again rather than draw a model that has drifted.  */
                 log_warning(`${gobj_short_name(gobj)}: '${command}' answered no record`);
+                if(topic_name === T_TOPICS || topic_name === T_COLS) {
+                    let write = priv.save_queue[0];
+                    mark_written(gobj, topic_name, write ? write.record : null);
+                }
                 priv.save_queue = [];
-                request_model(gobj);
+                priv.save_return = "";
+                priv.save_wrote = false;
+                gobj_publish_event(gobj, "EV_RECORD_WRITTEN", {
+                    treedb_name: gobj_read_str_attr(gobj, "treedb_name")
+                });
+                request_model(gobj, true);
                 return 0;
             }
         }
@@ -2907,14 +2975,24 @@ function ac_mt_command_answer(gobj, event, kw, src)
  *  the view was answered once, as failed -- and echoes the node
  *  event instead, which this view does not hear: there, Refresh is
  *  what reads the store.
+ *
+ *  It is a WRITE like any other for the host (EV_RECORD_WRITTEN):
+ *  the host was told nothing when it was given up, and it owns the
+ *  Save that publishes it. The reload keeps what this session wrote
+ *  (request_model()), and the record it answered marks its topic.
  ***************************************************************/
-function late_write_done(gobj, command, topic_name)
+function late_write_done(gobj, command, topic_name, data)
 {
     let priv = gobj.priv;
     let state = gobj_current_state(gobj);
 
     log_warning(`${gobj_short_name(gobj)}: '${command}' of '${topic_name}' was given up, ` +
         `and it was DONE: the model is read again`);
+    mark_written_record(gobj, topic_name, is_object(data) ? data
+        : (Array.isArray(data) && is_object(data[0]) ? data[0] : null));
+    gobj_publish_event(gobj, "EV_RECORD_WRITTEN", {
+        treedb_name: gobj_read_str_attr(gobj, "treedb_name")
+    });
     if(state === "ST_LOADING") {
         return 0;
     }
@@ -2926,7 +3004,37 @@ function late_write_done(gobj, command, topic_name)
         priv.reload_on_open = true;
         return 0;
     }
-    return request_model(gobj);
+    return request_model(gobj, true);
+}
+
+/***************************************************************
+ *  The topic a record written belongs to, read off the RECORD and
+ *  not off the screen: a write answered late may be about a topic
+ *  the operator has left. A column names its topic in its fkey
+ *  (`topics^<topic id>^cols`); a topic is its own id.
+ ***************************************************************/
+function mark_written_record(gobj, topic_name, record)
+{
+    let priv = gobj.priv;
+
+    if(!record) {
+        return;
+    }
+    if(topic_name === T_TOPICS && typeof record.id === "string" && record.id) {
+        priv.written[record.id] = true;
+        return;
+    }
+    if(topic_name !== T_COLS) {
+        return;
+    }
+    let refs = Array.isArray(record.topics) ? record.topics
+        : (typeof record.topics === "string" ? [record.topics] : []);
+    for(let ref of refs) {
+        let parts = String(ref).split("^");
+        if(parts.length >= 2 && parts[1]) {
+            priv.written[parts[1]] = true;
+        }
+    }
 }
 
 /***************************************************************
@@ -3004,7 +3112,7 @@ function ac_transport_state(gobj, event, kw, src)
     if((!priv.model || priv.reload_on_open) &&
             state !== "ST_LOADING" && state !== "ST_SAVING") {
         priv.reload_on_open = false;
-        return request_model(gobj);
+        return request_model(gobj, true);
     }
     render_toolbar(gobj);
     return 0;
@@ -3023,7 +3131,28 @@ function ac_language_changed(gobj, event, kw, src)
 
 function ac_refresh(gobj, event, kw, src)
 {
-    return request_model(gobj);
+    return request_model(gobj, false);
+}
+
+/***************************************************************
+ *  What a DIALOG sends while the model is being read again: the
+ *  Save of a form left open when the reload started, a
+ *  confirmation, an import. The loading screen took the rest of
+ *  the view away (request_model()); a dialog is the one thing the
+ *  operator can still reach, and what it asks is computed against
+ *  a model the answers in the air are about to replace.
+ *
+ *  Refused, and SAID -- and the dialog stays open with what was
+ *  typed, so the same Save works once the load is in. Undeclared,
+ *  it answered "Event NOT DEFINED in state ST_LOADING" and the
+ *  edit was gone with no word (third independent review).
+ ***************************************************************/
+function ac_wait_for_the_load(gobj, event, kw, src)
+{
+    log_warning(`${gobj_short_name(gobj)}: ${event} refused, the schemas are loading`);
+    yui_shell_show_error(yui_shell_of(gobj),
+        "the schemas are loading: try again when they are in", {t: t});
+    return -1;
 }
 
 /***************************************************************
@@ -3655,7 +3784,14 @@ function create_gclass(gclass_name)
     const states = [
         ["ST_IDLE", COMMON.slice()],
 
-        ["ST_LOADING", COMMON.slice()],
+        ["ST_LOADING", COMMON.concat([
+            ["EV_SAVE_COLUMN",      ac_wait_for_the_load,   null],
+            ["EV_SAVE_TOPIC",       ac_wait_for_the_load,   null],
+            ["EV_DELETE_ORPHAN",    ac_wait_for_the_load,   null],
+            ["EV_PREVIEW_IMPORT",   ac_wait_for_the_load,   null],
+            ["EV_APPLY_IMPORT",     ac_wait_for_the_load,   null],
+            ["EV_CONFIRMED",        ac_wait_for_the_load,   null]
+        ])],
 
         ["ST_EMPTY", COMMON.slice()],