@yuneta/gobj-ui 7.25.5 → 7.25.7

package/src/schema_editor_transport.wiring.test.js

@@ -0,0 +1,457 @@
+/***********************************************************************
+ *          schema_editor_transport.wiring.test.js
+ *
+ *      C_YUI_SCHEMA_EDITOR when the transport drops (M-1 of the
+ *      independent review of 7.25.4). A drop used to leave the editor
+ *      where it was: in ST_SAVING with its body busy, or in ST_LOADING
+ *      -- and the reconnect skipped the reload BECAUSE the state was
+ *      ST_LOADING. Only a reload of the page got it out.
+ *
+ *      Driven through the FSM on a document double, with a fake
+ *      transport whose state is the one the library reads
+ *      (`ST_SESSION` or not).
+ *
+ *          Copyright (c) 2026, ArtGins.
+ *          All Rights Reserved.
+ ***********************************************************************/
+import {describe, test, expect, beforeAll, beforeEach, vi} from "vitest";
+import {install_dom_double} from "../test/dom_double.js";
+
+install_dom_double();
+
+/*  What the editor SAYS is asserted on the call.  */
+const shown = [];
+vi.mock("./shell_modals.js", () => ({
+    yui_shell_show_error: (shell, message) => {
+        shown.push(message);
+        return {close() {}};
+    },
+    yui_shell_show_info: () => ({close() {}}),
+    yui_shell_show_modal: () => ({close() {}}),
+    yui_shell_confirm_danger: () => ({close() {}}),
+}));
+
+const {
+    SDATA_END,
+    gclass_create,
+    gobj_start_up, gobj_create_yuno, gobj_create, gobj_create_service,
+    gobj_start, gobj_send_event, gobj_read_attr,
+    gobj_change_state, gobj_current_state,
+    set_log_callback,
+} = await import("@yuneta/gobj-js");
+const {register_c_yui_schema_editor} = await import("./c_yui_schema_editor.js");
+
+const logged = [];
+const commands = [];
+
+const RECORDS = {
+    treedbs: [{id: "db", schema_version: 4}],
+    topics: [
+        {id: "db.users", value: "users", order: 1, pkey: "id", topic_version: 2,
+         treedbs: ["treedbs^db^topics"]},
+    ],
+    cols: [
+        {id: "db.users.id", value: "id", order: 1, type: "string",
+         flag: ["persistent", "required"], topics: ["topics^db.users^cols"]},
+    ],
+};
+
+/*  A transport out of session refuses in the RETURN, as C_IEVENT_CLI and
+ *  the routing adapters do: a request that did not leave is not waited for.  */
+function remote_command_parser(gobj, command, kw, src)
+{
+    if(gobj_current_state(gobj) !== "ST_SESSION") {
+        return `${command}: not in session`;
+    }
+    commands.push({command, kw, src});
+    return null;
+}
+
+let yuno = null;
+
+beforeAll(() => {
+    gobj_start_up(null, null, null, null, null, null, null);
+    set_log_callback((level, msg) => {
+        logged.push({level: String(level), msg: String(msg)});
+    });
+    gclass_create("C_TEST_HOST", [], [["ST_IDLE", []]], {}, 0, [SDATA_END()], {}, 0, 0, 0, 0);
+    gclass_create(
+        "C_TEST_EDITOR_HOST",
+        [["EV_POSITION_CHANGED", 0], ["EV_RECORD_WRITTEN", 0], ["EV_SCHEMA_CHECKED", 0]],
+        [["ST_IDLE", [
+            ["EV_POSITION_CHANGED", () => 0, null],
+            ["EV_RECORD_WRITTEN",   () => 0, null],
+            ["EV_SCHEMA_CHECKED",   () => 0, null]
+        ]]],
+        {}, 0, [SDATA_END()], {}, 0, 0, 0, 0
+    );
+    /*  The two states the library reads off a transport.  */
+    gclass_create(
+        "C_TEST_REMOTE",
+        [],
+        [["ST_DISCONNECTED", []], ["ST_SESSION", []]],
+        {mt_command_parser: remote_command_parser},
+        0, [SDATA_END()], {}, 0, 0, 0, 0
+    );
+    register_c_yui_schema_editor();
+    yuno = gobj_create_yuno("transport_yuno", "C_TEST_HOST", {});
+    gobj_start(yuno);
+});
+
+beforeEach(() => {
+    logged.length = 0;
+    commands.length = 0;
+    shown.length = 0;
+});
+
+function take(command)
+{
+    const out = commands.filter((c) => c.command === command);
+    for(const c of out) {
+        commands.splice(commands.indexOf(c), 1);
+    }
+    return out;
+}
+
+/*  The answer, the way a transport gives it: the request's frame on top.  */
+function answer(editor, remote, request, result, data, comment)
+{
+    gobj_send_event(editor, "EV_MT_COMMAND_ANSWER", {
+        result: result,
+        comment: comment || "",
+        data: data,
+        __md_iev__: {command_stack: [{command: request.command, kw: request.kw}]}
+    }, remote);
+}
+
+function answer_the_load(editor, remote)
+{
+    const asked = take("nodes");
+    for(const c of asked) {
+        /*  A copy, as a transport hands it: the editor patches what it is
+         *  given, and a shared fixture would carry one test's write into
+         *  the next.  */
+        answer(editor, remote, c, 0, JSON.parse(JSON.stringify(RECORDS[c.kw.topic_name])));
+    }
+    return asked.length;
+}
+
+function drop(editor, remote, host)
+{
+    gobj_change_state(remote, "ST_DISCONNECTED");
+    gobj_send_event(editor, "EV_TRANSPORT_STATE", {connected: false}, host);
+}
+
+function reconnect(editor, remote, host)
+{
+    gobj_change_state(remote, "ST_SESSION");
+    gobj_send_event(editor, "EV_TRANSPORT_STATE", {connected: true}, host);
+}
+
+function build(name, loaded)
+{
+    const remote = gobj_create_service(`${name}_remote`, "C_TEST_REMOTE", {}, yuno);
+    gobj_change_state(remote, "ST_SESSION");
+    const host = gobj_create(`${name}_host`, "C_TEST_EDITOR_HOST", {}, yuno);
+    const editor = gobj_create(`${name}_editor`, "C_YUI_SCHEMA_EDITOR", {
+        gobj_remote_yuno: remote,
+        treedb_name: "treedb_system_schema",
+        base_route: "/schemas"
+    }, host);
+    gobj_start(editor);
+    gobj_send_event(editor, "EV_TRANSPORT_STATE", {connected: true}, host);
+    if(loaded) {
+        expect(answer_the_load(editor, remote)).toBe(3);
+        gobj_send_event(editor, "EV_SHOW", {subpath: "db/users"}, host);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+    }
+    return {editor, remote, host};
+}
+
+/*  A write in flight: a new column, saved from its form.  */
+function start_a_write(editor, host)
+{
+    gobj_send_event(editor, "EV_SAVE_COLUMN", {
+        creating: true, topic: "users", values: {value: "name", type: "string"}
+    }, host);
+    expect(gobj_current_state(editor)).toBe("ST_SAVING");
+    const [write] = take("update-node");
+    expect(write).toBeTruthy();
+    return write;
+}
+
+function is_busy(editor)
+{
+    const $c = gobj_read_attr(editor, "$container");
+    return $c.querySelector(".SCHEMA_BODY").classList.contains("SCHEMA_BUSY");
+}
+
+function errors()
+{
+    return logged.filter((l) => l.level === "error").map((l) => l.msg);
+}
+
+function warnings()
+{
+    return logged.filter((l) => l.level === "warning").map((l) => l.msg);
+}
+
+describe("a drop while LOADING", () => {
+
+    test("the editor leaves ST_LOADING, and the reconnect loads again", () => {
+        const {editor, remote, host} = build("l1", false);
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+        expect(take("nodes").length).toBe(3);   /*  never answered  */
+
+        drop(editor, remote, host);
+        expect(gobj_current_state(editor)).toBe("ST_IDLE");
+
+        reconnect(editor, remote, host);
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(gobj_current_state(editor)).toBe("ST_TREEDBS");
+        expect(errors()).toEqual([]);
+    });
+
+    test("an answer of the load the drop abandoned is not counted in the next one", () => {
+        const {editor, remote, host} = build("l2", false);
+        const old = take("nodes");
+        drop(editor, remote, host);
+        reconnect(editor, remote, host);
+        const fresh = take("nodes");
+        expect(fresh.length).toBe(3);
+
+        /*  The three OLD answers arrive late: were they counted, the new
+         *  round would end here with the old data and 3 answers owed.  */
+        for(const c of old) {
+            answer(editor, remote, c, 0, []);
+        }
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+        for(const c of fresh) {
+            answer(editor, remote, c, 0, RECORDS[c.kw.topic_name]);
+        }
+        expect(gobj_current_state(editor)).toBe("ST_TREEDBS");
+        expect(editor.priv.model.treedbs.length).toBe(1);
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("a drop while SAVING", () => {
+
+    test("the write ends, said, the body answers again, and the reconnect reloads", () => {
+        const {editor, remote, host} = build("s1", true);
+        start_a_write(editor, host);
+        expect(is_busy(editor)).toBe(true);
+
+        drop(editor, remote, host);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(is_busy(editor)).toBe(false);
+        expect(shown).toEqual(["the connection dropped during the write"]);
+
+        /*  Whether the write landed is unknown: the model is asked again.  */
+        reconnect(editor, remote, host);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(errors()).toEqual([]);
+    });
+
+    test("the transport's own failure arriving FIRST is read as the drop it is", () => {
+        /*  A routing adapter settles what it had in flight when its session
+         *  closes, and that answer can reach the editor before the host's
+         *  EV_TRANSPORT_STATE. Read as a refusal, it ended the write and the
+         *  reconnect did not reload a model the write may have changed.  */
+        const {editor, remote, host} = build("s2", true);
+        const write = start_a_write(editor, host);
+
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        answer(editor, remote, write, -1, null, "the connection dropped");
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(shown).toEqual(["the connection dropped during the write"]);
+
+        gobj_send_event(editor, "EV_TRANSPORT_STATE", {connected: false}, host);
+        expect(shown.length).toBe(1);   /*  said once  */
+
+        reconnect(editor, remote, host);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(errors()).toEqual([]);
+    });
+
+    test("the answer of the write the drop ended is not taken for the next one", () => {
+        const {editor, remote, host} = build("s3", true);
+        const write = start_a_write(editor, host);
+        drop(editor, remote, host);
+        reconnect(editor, remote, host);
+        answer_the_load(editor, remote);
+
+        const second = start_a_write(editor, host);
+        /*  The first write's answer, late: it must not end the second.  */
+        answer(editor, remote, write, 0, {id: "db.users.name", value: "name",
+            topics: ["topics^db.users^cols"]});
+        expect(gobj_current_state(editor)).toBe("ST_SAVING");
+
+        /*  ...and it says the first one was DONE, so once the second ends
+         *  the model is read again (late_write_done()).  */
+        answer(editor, remote, second, 0, {id: "db.users.name", value: "name", order: 2,
+            type: "string", topics: ["topics^db.users^cols"]});
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(errors()).toEqual([]);
+    });
+});
+
+/*
+ *  The regression of 7.25.6: a navigation DURING a reload. The load was
+ *  matched by its round AND by the state being ST_LOADING, and EV_SHOW
+ *  moved the editor out of ST_LOADING while its three `nodes` were in
+ *  flight. Every answer was then "for a load that is over", the reload
+ *  never landed, and request_model() had already emptied the records: the
+ *  next write patched an empty store and the model lost every treedb.
+ */
+describe("a navigation DURING a reload", () => {
+
+    test("refresh, move, write: the model keeps every treedb", () => {
+        const {editor, remote, host} = build("n1", true);
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        gobj_send_event(editor, "EV_SHOW", {subpath: "db"}, host);
+        gobj_send_event(editor, "EV_SHOW", {subpath: "db/users"}, host);
+        expect(answer_the_load(editor, remote)).toBe(3);
+
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(editor.priv.pending).toBe(0);
+
+        const write = start_a_write(editor, host);
+        answer(editor, remote, write, 0, {id: "db.users.name", value: "name", order: 2,
+            type: "string", topics: ["topics^db.users^cols"]});
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(editor.priv.model.treedbs.length).toBe(1);
+        expect(editor.priv.model.treedbs[0].topics[0].cols.length).toBe(2);
+        expect(warnings()).toEqual([]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("the editor stays in ST_LOADING, and lands where the host said last", () => {
+        const {editor, remote, host} = build("n2", true);
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        gobj_send_event(editor, "EV_SHOW", {subpath: "db"}, host);
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(gobj_current_state(editor)).toBe("ST_TOPICS");
+        expect(editor.priv.treedb_id).toBe("db");
+        expect(editor.priv.topic_name).toBe("");
+        expect(warnings()).toEqual([]);
+    });
+
+    test("the reload of a reconnect, with a move in the middle", () => {
+        const {editor, remote, host} = build("n3", true);
+        start_a_write(editor, host);
+        drop(editor, remote, host);             /*  the reconnect will reload  */
+        shown.length = 0;
+        reconnect(editor, remote, host);
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+
+        gobj_send_event(editor, "EV_SHOW", {subpath: "db"}, host);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(gobj_current_state(editor)).toBe("ST_TOPICS");
+        expect(editor.priv.pending).toBe(0);
+        expect(editor.priv.records.cols.length).toBe(1);
+        expect(editor.priv.model.treedbs.length).toBe(1);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a drop after the move: the move is applied on the model kept, and the reconnect reloads", () => {
+        const {editor, remote, host} = build("n4", true);
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        take("nodes");                          /*  never answered  */
+        gobj_send_event(editor, "EV_SHOW", {subpath: "db"}, host);
+
+        drop(editor, remote, host);
+        expect(gobj_current_state(editor)).toBe("ST_TOPICS");
+
+        reconnect(editor, remote, host);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(gobj_current_state(editor)).toBe("ST_TOPICS");
+        expect(editor.priv.model.treedbs.length).toBe(1);
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("a position with no model and no load", () => {
+
+    test("does not claim a load, and the session loads it", () => {
+        const remote = gobj_create_service("p1_remote", "C_TEST_REMOTE", {}, yuno);
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        const host = gobj_create("p1_host", "C_TEST_EDITOR_HOST", {}, yuno);
+        const editor = gobj_create("p1_editor", "C_YUI_SCHEMA_EDITOR", {
+            gobj_remote_yuno: remote,
+            treedb_name: "treedb_system_schema",
+            base_route: "/schemas"
+        }, host);
+        gobj_start(editor);                     /*  its load cannot leave  */
+        logged.length = 0;
+        expect(gobj_current_state(editor)).toBe("ST_IDLE");
+
+        gobj_send_event(editor, "EV_SHOW", {subpath: "db/users"}, host);
+        expect(gobj_current_state(editor)).toBe("ST_IDLE");
+
+        reconnect(editor, remote, host);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("the drop is settled ONCE", () => {
+
+    test("a load cut by the drop: the transport's three failures are one event", () => {
+        const {editor, remote, host} = build("o1", true);
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        const cut = take("nodes");
+        expect(cut.length).toBe(3);
+
+        /*  A routing adapter settles all three when its session closes,
+         *  before (or after) the host's edge.  */
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        for(const c of cut) {
+            answer(editor, remote, c, -1, null, "the connection dropped");
+        }
+        gobj_send_event(editor, "EV_TRANSPORT_STATE", {connected: false}, host);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(warnings().length).toBe(1);
+        expect(warnings()[0]).toMatch(/dropped during the load/);
+        expect(errors()).toEqual([]);
+    });
+
+    test("the host's edge first: the failures that follow are not said again", () => {
+        const {editor, remote, host} = build("o2", true);
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        const cut = take("nodes");
+
+        drop(editor, remote, host);
+        for(const c of cut) {
+            answer(editor, remote, c, -1, null, "the connection dropped");
+        }
+        expect(warnings().length).toBe(1);
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("a write answered after it was given up", () => {
+
+    test("it was DONE: the model is read again", () => {
+        const {editor, remote, host} = build("w1", true);
+        const write = start_a_write(editor, host);
+        drop(editor, remote, host);
+        reconnect(editor, remote, host);
+        answer_the_load(editor, remote);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+
+        /*  The treedb says it wrote it, after all.  */
+        answer(editor, remote, write, 0, {id: "db.users.name", value: "name",
+            topics: ["topics^db.users^cols"]});
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+        expect(take("nodes").length).toBe(3);
+        expect(errors()).toEqual([]);
+    });
+});

package/src/shell_modals.js

@@ -111,6 +111,14 @@ function maybe_apply_translator($node, opts)
  *      Non-blocking, auto-dismiss after `opts.timeout` ms (default
  *      5000).  `opts.timeout = 0` disables auto-dismiss.
  *      Returns `{ close() }` so callers can dismiss programmatically.
+ *
+ *      ONE toast per message on screen: a string message of the same
+ *      kind as a toast still showing is not stacked under it -- that
+ *      toast is kept, its time starts again, and its handle is
+ *      returned. One close of a transport settles every request it
+ *      cut, each view shows its failure, and the operator got a
+ *      column of identical "the connection dropped". A message built
+ *      of nodes is never merged: its text is not a key.
  ***************************************************************/
 function show_notification(shell, kind, message, opts)
 {
@@ -120,6 +128,16 @@ function show_notification(shell, kind, message, opts)
         return { close: () => {} };
     }
 
+    let key = (typeof message === "string") ? `${kind}\u0000${message}` : null;
+    if(key !== null) {
+        for(let $shown of Array.from($layer.children)) {
+            if($shown.__toast_key__ === key && $shown.__toast__) {
+                $shown.__toast__.restart();
+                return $shown.__toast__.handle;
+            }
+        }
+    }
+
     let p_attrs = (typeof message === "string")
         ? {i18n: message}
         : {};
@@ -158,11 +176,21 @@ function show_notification(shell, kind, message, opts)
     }
 
     let timeout = (opts && opts.timeout != null) ? opts.timeout : 5000;
-    if(timeout > 0) {
-        timeout_id = setTimeout(close, timeout);
-    }
+    let restart = function() {
+        if(timeout_id) {
+            clearTimeout(timeout_id);
+            timeout_id = null;
+        }
+        if(timeout > 0) {
+            timeout_id = setTimeout(close, timeout);
+        }
+    };
+    restart();
 
-    return { close };
+    let handle = { close };
+    $note.__toast_key__ = key;
+    $note.__toast__ = {handle: handle, restart: restart};
+    return handle;
 }
 
 

package/src/shell_toast_once.test.js

@@ -0,0 +1,64 @@
+/***********************************************************************
+ *          shell_toast_once.test.js
+ *
+ *      A toast that says what one already on screen says is not
+ *      stacked under it: one close of the transport settles every
+ *      request it cut, each view that asked shows its failure, and
+ *      the operator got a column of identical "the connection
+ *      dropped" (low of the independent review of the 2nd round).
+ *
+ *          Copyright (c) 2026, ArtGins.
+ *          All Rights Reserved.
+ ***********************************************************************/
+import {describe, test, expect, beforeEach} from "vitest";
+import {install_dom_double} from "../test/dom_double.js";
+
+install_dom_double();
+
+const {
+    yui_shell_show_error,
+    yui_shell_show_info,
+} = await import("./shell_modals.js");
+
+let shell = null;
+
+function toasts()
+{
+    return shell.priv.layers.notification.children;
+}
+
+beforeEach(() => {
+    shell = {priv: {layers: {notification: document.createElement("div")}}};
+});
+
+describe("one toast per message on screen", () => {
+
+    test("the same error twice is ONE toast", () => {
+        yui_shell_show_error(shell, "the connection dropped");
+        yui_shell_show_error(shell, "the connection dropped");
+        yui_shell_show_error(shell, "the connection dropped");
+        expect(toasts().length).toBe(1);
+    });
+
+    test("different messages, or kinds, still stack", () => {
+        yui_shell_show_error(shell, "the connection dropped");
+        yui_shell_show_error(shell, "the connection dropped during the write");
+        yui_shell_show_info(shell, "the connection dropped");
+        expect(toasts().length).toBe(3);
+    });
+
+    test("closing the one on screen: the next one is shown", () => {
+        const first = yui_shell_show_error(shell, "the connection dropped");
+        first.close();
+        expect(toasts().length).toBe(0);
+        yui_shell_show_error(shell, "the connection dropped");
+        expect(toasts().length).toBe(1);
+    });
+
+    test("the handle of the repeat closes the toast on screen", () => {
+        yui_shell_show_error(shell, "the connection dropped");
+        const again = yui_shell_show_error(shell, "the connection dropped");
+        again.close();
+        expect(toasts().length).toBe(0);
+    });
+});