@yuneta/gobj-ui 7.25.8 → 7.25.9

package/src/schema_editor_reload.wiring.test.js

@@ -16,6 +16,15 @@
  *      the reload of a late write that forgot this session's marks and
  *      never told the host a write had landed.
  *
+ *      The fourth independent review (same day) found what a reload
+ *      still left behind: a dialog opened on the model it replaced
+ *      (its Save wrote the old record over the newer one), a load
+ *      refused IN session that blanked the model, a late write whose
+ *      list_dict fkey marked nothing, a write answered with no record
+ *      that owed a second reload and dropped the rest of its queue in
+ *      silence, and a toolbar gated on the state instead of on the
+ *      treedb being there.
+ *
  *      Driven through the FSM on a document double, with a fake
  *      transport whose state is the one the library reads.
  *
@@ -264,6 +273,36 @@ function errors()
     return logged.filter((l) => l.level === "error").map((l) => l.msg);
 }
 
+function not_defined()
+{
+    return logged.filter((l) => /NOT DEFINED/i.test(l.msg)).map((l) => l.msg);
+}
+
+/*  The load, answered with records other than the ones it started on:
+ *  somebody else wrote the store meanwhile.  */
+function answer_the_load_with(editor, remote, records)
+{
+    const asked = take("nodes");
+    for(const c of asked) {
+        answer(editor, remote, c, 0, JSON.parse(JSON.stringify(records[c.kw.topic_name])));
+    }
+    return asked.length;
+}
+
+function records_with(change)
+{
+    const records = JSON.parse(JSON.stringify(RECORDS));
+    change(records);
+    return records;
+}
+
+/*  What the editor says while a load is in the air, and when one lands
+ *  under an open dialog.  */
+const WAIT = "the schemas are loading: wait for them";
+const STALE = "the schemas were read again: open the dialog again";
+const KEPT = "cannot read the schemas again: the previous ones stay";
+const NOT_SENT = "the treedb did not describe a write back: the writes after it were not sent";
+
 describe("the screen of a reload", () => {
 
     test("Refresh on the columns: the old screen goes, the toolbar stops answering", () => {
@@ -318,7 +357,7 @@ describe("the screen of a reload", () => {
 
 describe("a form open when a reload starts", () => {
 
-    test("its Save is refused, said, the form stays, and it saves once the load is in", () => {
+    test("its Save is refused and said, and the load that lands closes it: nothing written", () => {
         const {editor, remote, host} = build("f1", "db/users");
         gobj_send_event(editor, "EV_ADD_COLUMN", {}, editor);
         expect(modals.length).toBe(1);
@@ -329,15 +368,17 @@ describe("a form open when a reload starts", () => {
         form.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
 
         expect(errors()).toEqual([]);
-        expect(shown).toEqual(["the schemas are loading: try again when they are in"]);
+        /*  Not "try again": the same Save, once the load is in, wrote a
+         *  form built on the model the load replaced.  */
+        expect(shown).toEqual([WAIT]);
         expect(form.closed).toBe(false);
         expect(take("update-node")).toEqual([]);
 
         answer_the_load(editor, remote);
-        form.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
         expect(form.closed).toBe(true);
-        const [write] = take("update-node");
-        expect(write.kw.record.value).toBe("email");
+        expect(shown).toEqual([WAIT, STALE]);
+        form.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
+        expect(take("update-node")).toEqual([]);
         expect(errors()).toEqual([]);
     });
 
@@ -346,7 +387,7 @@ describe("a form open when a reload starts", () => {
         gobj_send_event(editor, "EV_REFRESH", {}, host);
         gobj_send_event(editor, "EV_CONFIRMED", {what: "column", topic: "users", col: "id"}, editor);
         expect(errors()).toEqual([]);
-        expect(shown).toEqual(["the schemas are loading: try again when they are in"]);
+        expect(shown).toEqual([WAIT]);
         expect(take("update-node")).toEqual([]);
         answer_the_load(editor, remote);
     });
@@ -439,8 +480,10 @@ describe("a write given up that was DONE", () => {
         expect(editor.priv.written).toEqual({"db.users": true});
         published.length = 0;
 
+        /*  The shape the store answers with: `nodes`/`update-node` ask
+         *  for list_dict, so a fkey comes back as a list of refs.  */
         answer(editor, remote, w2, 0, {id: "db.users.email", value: "email",
-            type: "string", topics: ["topics^db.users^cols"]});
+            type: "string", topics: [{id: "db.users", topic_name: "topics", hook_name: "cols"}]});
         expect(published).toContain("EV_RECORD_WRITTEN");
         expect(gobj_current_state(editor)).toBe("ST_LOADING");
         answer_the_load(editor, remote);
@@ -471,3 +514,274 @@ describe("a write given up that was DONE", () => {
         expect(editor.priv.written).toEqual({});
     });
 });
+
+describe("a dialog built on the model a reload replaced (fourth review)", () => {
+
+    test("an edit form: the load that lands closes it, and its Save writes nothing", () => {
+        const {editor, remote, host} = build("s1", "db/users");
+        gobj_send_event(editor, "EV_EDIT_COLUMN", {col: "id"}, host);
+        const form = modals[modals.length - 1];
+        form.$content.querySelector('[data-name="description"]').value = "mine";
+
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        answer_the_load_with(editor, remote, records_with((r) => {
+            r.cols[0].description = "NEWER";
+            r.cols[0].header = "Newer header";
+        }));
+        expect(form.closed).toBe(true);
+        expect(shown).toEqual([STALE]);
+        expect(editor.priv.dialog).toBe(null);
+
+        /*  The form's button, pressed anyway (a stale screen, a keyboard):
+         *  the record it would write is the OLD one with one field changed,
+         *  over the newer one.  */
+        form.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
+        expect(take("update-node")).toEqual([]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("the column of the open form is gone after the reload: closed, no ERROR", () => {
+        const {editor, remote, host} = build("s2", "db/users");
+        gobj_send_event(editor, "EV_EDIT_COLUMN", {col: "id"}, host);
+        const form = modals[modals.length - 1];
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        answer_the_load_with(editor, remote, records_with((r) => {
+            r.cols = [];
+        }));
+        expect(form.closed).toBe(true);
+        form.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
+        expect(take("update-node")).toEqual([]);
+        expect(errors()).toEqual([]);
+        expect(not_defined()).toEqual([]);
+    });
+
+    test("an import plan is not run on the model that replaced the one it was planned on", () => {
+        const {editor, remote, host} = build("s3", "db");
+        gobj_send_event(editor, "EV_IMPORT", {}, host);
+        const dialog = modals[modals.length - 1];
+        gobj_send_event(editor, "EV_PREVIEW_IMPORT", {
+            prune: false,
+            text: JSON.stringify({id: "db", topics: [{id: "users", pkey: "id", cols: [
+                {id: "id", type: "string", flag: ["persistent", "required"]},
+                {id: "email", type: "string"}
+            ]}]})
+        }, editor);
+        expect(editor.priv.import_plan.writes.length).toBeGreaterThan(0);
+
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        expect(editor.priv.import_plan).toBe(null);
+        answer_the_load_with(editor, remote, records_with((r) => {
+            r.cols.push({id: "db.users.email", value: "email", order: 2, type: "integer",
+                         topics: ["topics^db.users^cols"]});
+        }));
+        expect(dialog.closed).toBe(true);
+
+        dialog.$content.querySelector(".SCHEMA_IMPORT_RUN").disabled = false;
+        dialog.$content.querySelector(".SCHEMA_IMPORT_RUN").click();
+        expect(take("update-node")).toEqual([]);
+        expect(take("delete-node")).toEqual([]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a confirmation decided on the model a reload replaced is not applied", () => {
+        const {editor, remote, host} = build("s4", "db/users");
+        const kw = {what: "column", topic: "users", col: "id",
+                    model_gen: editor.priv.model_gen};
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        answer_the_load(editor, remote);
+        gobj_send_event(editor, "EV_CONFIRMED", kw, editor);
+        expect(take("update-node")).toEqual([]);
+        expect(shown).toEqual([STALE]);
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("a load that fails IN session (fourth review)", () => {
+
+    test("keeps the model, the screen and the open form, says so, and owes the reload", () => {
+        const {editor, remote, host} = build("b1", "db/users");
+        gobj_send_event(editor, "EV_EDIT_COLUMN", {col: "id"}, host);
+        const form = modals[modals.length - 1];
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        const asked = take("nodes");
+        answer(editor, remote, asked[0], -1, null, "deadline");
+        answer(editor, remote, asked[1], 0, RECORDS[asked[1].kw.topic_name]);
+        answer(editor, remote, asked[2], 0, RECORDS[asked[2].kw.topic_name]);
+
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(editor.priv.model.treedbs.length).toBe(1);
+        expect(editor.priv.records.treedbs.length).toBe(1);
+        expect(editor.priv.reload_on_open).toBe(true);
+        expect(shown).toEqual([KEPT]);
+        expect(form.closed).toBe(false);
+        expect($in(editor, ".SCHEMA_BODY .SCHEMA_COLUMNS")).toBeTruthy();
+
+        /*  The form was built on the model still shown: it works.  */
+        form.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
+        expect(not_defined()).toEqual([]);
+        expect(take("update-node").length).toBe(1);
+        expect(errors()).toEqual([]);
+    });
+
+    test("with no model before it, it is the empty screen it always was", () => {
+        const remote = gobj_create_service("b2_remote", "C_TEST_REMOTE", {}, yuno);
+        gobj_change_state(remote, "ST_SESSION");
+        const host = gobj_create("b2_host", "C_TEST_EDITOR_HOST", {}, yuno);
+        const editor = gobj_create("b2_editor", "C_YUI_SCHEMA_EDITOR", {
+            gobj_remote_yuno: remote, treedb_name: "treedb_system_schema"
+        }, host);
+        gobj_start(editor);
+        for(const c of take("nodes")) {
+            answer(editor, remote, c, -1, null, "deadline");
+        }
+        expect(gobj_current_state(editor)).toBe("ST_IDLE");
+        expect(editor.priv.model).toBe(null);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a drop that cuts a reload keeps the records the model was built on", () => {
+        const {editor, remote, host} = build("b3", "db/users");
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        const asked = take("nodes");
+        answer(editor, remote, asked[0], 0, []);   /*  half a load  */
+        drop(editor, remote, host);
+        expect(editor.priv.records.treedbs.length).toBe(1);
+        expect(editor.priv.records.cols.length).toBe(1);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+    });
+});
+
+describe("a late write, in the shape the store answers (fourth review)", () => {
+
+    test("a list_dict fkey marks the topic the column belongs to", () => {
+        const {editor, remote, host} = build("c1", "db/users");
+        const w = start_a_write(editor, host, "name");
+        drop(editor, remote, host);
+        reconnect(editor, remote, host);
+        answer_the_load(editor, remote);
+        expect(editor.priv.written).toEqual({});
+        answer(editor, remote, w, 0, {id: "db.users.name", value: "name", type: "string",
+            topics: [{id: "db.users", topic_name: "topics", hook_name: "cols"}]});
+        expect(editor.priv.written).toEqual({"db.users": true});
+        answer_the_load(editor, remote);
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("a write answered with no record (fourth review)", () => {
+
+    test("the reload it asks is the one owed: the next write does not load again", () => {
+        const {editor, remote, host} = build("n1", "db/users");
+        const w1 = start_a_write(editor, host, "a1");
+        drop(editor, remote, host);
+        reconnect(editor, remote, host);
+        answer_the_load(editor, remote);
+        const w2 = start_a_write(editor, host, "a2");
+        answer(editor, remote, w1, 0, {id: "db.users.a1", value: "a1",
+            topics: [{id: "db.users", topic_name: "topics", hook_name: "cols"}]});
+        expect(editor.priv.reload_after_write).toBe(true);
+        answer(editor, remote, w2, 0, null);
+        expect(editor.priv.reload_after_write).toBe(false);
+        answer_the_load(editor, remote);
+
+        const w3 = start_a_write(editor, host, "a3");
+        answer(editor, remote, w3, 0, {id: "db.users.a3", value: "a3",
+            topics: [{id: "db.users", topic_name: "topics", hook_name: "cols"}]});
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(take("nodes")).toEqual([]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("the writes queued after it are said, not dropped in silence", () => {
+        const {editor, remote, host} = build("n2", "db/users");
+        for(const name of ["a", "b"]) {
+            const w = start_a_write(editor, host, name);
+            answer(editor, remote, w, 0, {id: `db.users.${name}`, value: name, type: "string",
+                order: name === "a" ? 2 : 3, topics: ["topics^db.users^cols"]});
+        }
+        gobj_send_event(editor, "EV_MOVE_COLUMN", {from: 0, to: 3}, host);
+        expect(gobj_current_state(editor)).toBe("ST_SAVING");
+        expect(editor.priv.save_queue.length).toBeGreaterThan(1);
+        const [first] = take("update-node");
+        answer(editor, remote, first, 0, null);
+        expect(take("update-node")).toEqual([]);
+        expect(shown).toEqual([NOT_SENT]);
+        expect(logged.some((l) => l.level === "warning" && /not sent/.test(l.msg))).toBe(true);
+        answer_the_load(editor, remote);
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("the toolbar of a treedb that is not there (fourth review)", () => {
+
+    test("offers Back and Refresh, and nothing that needs the treedb", () => {
+        const {editor, remote, host} = build("t1", "db");
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        answer_the_load_with(editor, remote, records_with((r) => {
+            r.treedbs = [{id: "other", schema_version: 1}];
+            r.topics = [];
+            r.cols = [];
+        }));
+        expect($in(editor, ".SCHEMA_BACK")).toBeTruthy();
+        expect($in(editor, ".SCHEMA_REFRESH_BTN")).toBeTruthy();
+        for(const cls of ["SCHEMA_DIAGRAM_BTN", "SCHEMA_VALIDATE_BTN", "SCHEMA_EXPORT_BTN",
+                          "SCHEMA_IMPORT_BTN", "SCHEMA_ADD_TOPIC_BTN"]) {
+            expect([cls, !!$in(editor, `.${cls}`)]).toEqual([cls, false]);
+        }
+        for(const $b of $all(editor, ".SCHEMA_TOOLBAR button")) {
+            if($b.classList.contains("SCHEMA_REFRESH_BTN") || $b.classList.contains("SCHEMA_BACK")) {
+                continue;
+            }
+            $b.click();
+        }
+        expect(errors()).toEqual([]);
+    });
+
+    test("a topic that is not there offers no New column", () => {
+        const {editor, remote, host} = build("t2", "db/users");
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        answer_the_load_with(editor, remote, records_with((r) => {
+            r.topics = [];
+            r.cols = [];
+        }));
+        expect(!!$in(editor, ".SCHEMA_ADD_COL_BTN")).toBe(false);
+        expect($in(editor, ".SCHEMA_BACK")).toBeTruthy();
+    });
+});
+
+describe("every control of the editor's dialogs is named (fourth review)", () => {
+
+    /*  A control a wrapping <label> names is the one shape that needs no
+     *  attribute (CLAUDE.md, "title + aria-label").  */
+    function unnamed($root)
+    {
+        const out = [];
+        for(const $c of $root.querySelectorAll("button, input, select, textarea")) {
+            if($c.getAttribute("type") === "checkbox" && $c.closest("label")) {
+                continue;
+            }
+            const ok = $c.getAttribute("title") !== null &&
+                $c.getAttribute("aria-label") !== null &&
+                !!$c.getAttribute("data-i18n-title") &&
+                !!$c.getAttribute("data-i18n-aria-label");
+            if(!ok) {
+                out.push(`${$c.tagName} ${$c.className || $c.getAttribute("data-name") || ""}`);
+            }
+        }
+        return out;
+    }
+
+    test("the column form, the topic form and the import", () => {
+        const {editor, remote, host} = build("a1", "db/users");
+        gobj_send_event(editor, "EV_EDIT_COLUMN", {col: "id"}, host);
+        expect(unnamed(modals[modals.length - 1].$content)).toEqual([]);
+
+        gobj_send_event(editor, "EV_SHOW", {subpath: "db"}, host);
+        gobj_send_event(editor, "EV_EDIT_TOPIC", {topic: "users"}, host);
+        expect(unnamed(modals[modals.length - 1].$content)).toEqual([]);
+
+        gobj_send_event(editor, "EV_IMPORT", {}, host);
+        expect(unnamed(modals[modals.length - 1].$content)).toEqual([]);
+        expect(errors()).toEqual([]);
+    });
+});

package/src/shell_modals.js

@@ -153,7 +153,8 @@ function show_notification(shell, kind, message, opts)
         ["div", {class: `TOAST notification yui-notification ${yui_tint(kind)}`,
                  role: kind === "danger" ? "alert" : "status"},
             [
-                ["button", {class: "TOAST_CLOSE delete", "aria-label": t("close"), "data-i18n-aria-label": "close"}],
+                ["button", {class: "TOAST_CLOSE delete", title: t("close"), "data-i18n-title": "close",
+                    "aria-label": t("close"), "data-i18n-aria-label": "close"}],
                 ["p", {...p_attrs, class: "TOAST_MSG"}, message]
             ]
         ]
@@ -284,7 +285,8 @@ export function yui_shell_show_modal(shell, content, opts)
                     .concat(title
                         ? [["span", {class: "MODAL_TITLE_KIND", i18n: title}, title]]
                         : [])],
-            ["button", {class: "MODAL_CLOSE yui-dialog-x", type: "button", "aria-label": t("close"), "data-i18n-aria-label": "close"},
+            ["button", {class: "MODAL_CLOSE yui-dialog-x", type: "button", title: t("close"), "data-i18n-title": "close",
+                    "aria-label": t("close"), "data-i18n-aria-label": "close"},
                 [["i", {class: "yi-xmark"}]]],
         ]];
         let body = ["div", {class: "MODAL_BODY yui-dialog-body"}, inner ? [inner] : []];
@@ -304,7 +306,8 @@ export function yui_shell_show_modal(shell, content, opts)
         if(with_close) {
             modal_children.push(
                 ["button", {class: "MODAL_CLOSE modal-close is-large",
-                            "aria-label": t("close"), "data-i18n-aria-label": "close"}]
+                            title: t("close"), "data-i18n-title": "close",
+                    "aria-label": t("close"), "data-i18n-aria-label": "close"}]
             );
         }
     }
@@ -519,7 +522,8 @@ function build_dialog(shell, message, buttons, opts)
         );
     }
     $card_children.push(
-        ["button", {class: "CONFIRM_CLOSE delete yui-confirm-x", "aria-label": t("close"), "data-i18n-aria-label": "close"}],
+        ["button", {class: "CONFIRM_CLOSE delete yui-confirm-x", title: t("close"), "data-i18n-title": "close",
+                    "aria-label": t("close"), "data-i18n-aria-label": "close"}],
         ["section", {class: "CONFIRM_BODY modal-card-body has-text-centered"},
             $body_children],
         ["footer", {class: "CONFIRM_FOOT modal-card-foot"}, $footer_children]

package/src/shell_toast_once.test.js

@@ -11,6 +11,10 @@
  *      review): its handle and its time are its own, and the toast
  *      stays while any caller still holds it.
  *
+ *      And every ✕ this module draws is a control with a NAME: a
+ *      `title` and an `aria-label`, both translatable (fourth
+ *      independent review: TOAST_CLOSE had the label only).
+ *
  *          Copyright (c) 2026, ArtGins.
  *          All Rights Reserved.
  ***********************************************************************/
@@ -22,6 +26,8 @@ install_dom_double();
 const {
     yui_shell_show_error,
     yui_shell_show_info,
+    yui_shell_show_modal,
+    yui_shell_confirm_danger,
 } = await import("./shell_modals.js");
 
 let shell = null;
@@ -123,3 +129,39 @@ describe("a repeat is its own caller", () => {
         expect(toasts().length).toBe(1);
     });
 });
+
+describe("every close control is named", () => {
+
+    function named($b)
+    {
+        /*  The text itself is whatever the app's i18next answers (none
+         *  here); what is checked is that both are THERE and carry the
+         *  key a language change re-translates them by.  */
+        return {
+            title:      $b.getAttribute("title") !== null,
+            title_key:  $b.getAttribute("data-i18n-title"),
+            label:      $b.getAttribute("aria-label") !== null,
+            label_key:  $b.getAttribute("data-i18n-aria-label"),
+        };
+    }
+
+    const NAMED = {title: true, title_key: "close", label: true, label_key: "close"};
+
+    test("the toast's", () => {
+        yui_shell_show_error(shell, "the connection dropped");
+        expect(named(toasts()[0].querySelector(".TOAST_CLOSE"))).toEqual(NAMED);
+    });
+
+    test("a modal's, dialog or plain, and a confirmation's", () => {
+        shell.priv.layers.modal = document.createElement("div");
+        yui_shell_show_modal(shell, document.createElement("div"), {dialog: true, title: "x"});
+        yui_shell_show_modal(shell, document.createElement("div"), {});
+        yui_shell_confirm_danger(shell, "delete this column?");
+        const $closes = shell.priv.layers.modal.querySelectorAll(
+            ".MODAL_CLOSE, .CONFIRM_CLOSE");
+        expect($closes.length).toBe(3);
+        for(const $b of $closes) {
+            expect(named($b)).toEqual(NAMED);
+        }
+    });
+});