@yuneta/gobj-ui 7.25.9 → 7.25.10

package/src/schema_editor_reload.wiring.test.js

@@ -300,7 +300,8 @@ function records_with(change)
  *  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 KEPT = "cannot read the schemas again: the ones shown may be out of date, your next change reads them first";
+const OWED = "the schemas shown may be out of date: they are read again, try again when they are in";
 const NOT_SENT = "the treedb did not describe a write back: the writes after it were not sent";
 
 describe("the screen of a reload", () => {
@@ -616,10 +617,18 @@ describe("a load that fails IN session (fourth review)", () => {
         expect(form.closed).toBe(false);
         expect($in(editor, ".SCHEMA_BODY .SCHEMA_COLUMNS")).toBeTruthy();
 
-        /*  The form was built on the model still shown: it works.  */
+        /*  The form was built on a model that may be older than the
+         *  store: its Save would write every field of it. It runs the
+         *  reload owed instead (fifth review), and the load that lands
+         *  closes the form.  */
         form.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
         expect(not_defined()).toEqual([]);
-        expect(take("update-node").length).toBe(1);
+        expect(take("update-node")).toEqual([]);
+        expect(shown).toEqual([KEPT, OWED]);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(form.closed).toBe(true);
+        expect(shown).toEqual([KEPT, OWED, STALE]);
+        expect(editor.priv.reload_on_open).toBe(false);
         expect(errors()).toEqual([]);
     });
 
@@ -785,3 +794,224 @@ describe("every control of the editor's dialogs is named (fourth review)", () =>
         expect(errors()).toEqual([]);
     });
 });
+
+describe("the export's two views are controls (fifth review)", () => {
+
+    test("each is a named button that says which one is shown, and switches the text", () => {
+        const {editor, remote, host} = build("x1", "db");
+        gobj_send_event(editor, "EV_EXPORT", {}, host);
+        const $content = modals[modals.length - 1].$content;
+        const $tabs = [...$content.querySelectorAll(".SCHEMA_EXPORT_TAB")];
+        expect($tabs.map(($b) => [
+            $b.tagName.toLowerCase(),
+            $b.getAttribute("type"),
+            $b.getAttribute("title") !== null,
+            $b.getAttribute("data-i18n-title"),
+            $b.getAttribute("aria-label") !== null,
+            $b.getAttribute("data-i18n-aria-label"),
+            $b.getAttribute("aria-pressed"),
+        ])).toEqual([
+            ["button", "button", true, "schema as c source", true, "schema as c source", "true"],
+            ["button", "button", true, "schema as json", true, "schema as json", "false"],
+        ]);
+
+        const $text = $content.querySelector(".SCHEMA_EXPORT_TEXT");
+        $tabs[1].click();
+        expect($text.value.trim().startsWith("{")).toBe(true);
+        expect($tabs.map(($b) => $b.getAttribute("aria-pressed"))).toEqual(["false", "true"]);
+        $tabs[0].click();
+        expect($text.value.trim().startsWith("{")).toBe(false);
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("a Refresh asked while a load is in flight (fifth review)", () => {
+
+    test("keeps the records of the model shown, not the half the first load got", () => {
+        const {editor, remote, host} = build("h1", "db/users");
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        const first = take("nodes");
+        answer(editor, remote, first[0], 0, []);    /*  half a load  */
+
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        const second = take("nodes");
+        expect(second.length).toBe(3);
+        drop(editor, remote, host);
+        expect(editor.priv.records.treedbs.length).toBe(1);
+        expect(editor.priv.records.topics.length).toBe(1);
+        expect(editor.priv.records.cols.length).toBe(1);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(errors()).toEqual([]);
+    });
+
+    test("...and so does one that fails in session", () => {
+        const {editor, remote, host} = build("h2", "db/users");
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        const first = take("nodes");
+        answer(editor, remote, first[0], 0, []);
+
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        const second = take("nodes");
+        answer(editor, remote, second[0], -1, null, "deadline");
+        answer(editor, remote, second[1], 0, []);
+        answer(editor, remote, second[2], 0, []);
+        expect(editor.priv.records.cols.length).toBe(1);
+        expect(editor.priv.model.treedbs.length).toBe(1);
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("the reload a load refused in session owes (fifth review)", () => {
+
+    function refused_load(name, subpath)
+    {
+        const built = build(name, subpath);
+        gobj_send_event(built.editor, "EV_REFRESH", {}, built.host);
+        const asked = take("nodes");
+        answer(built.editor, built.remote, asked[0], -1, null, "deadline");
+        answer(built.editor, built.remote, asked[1], 0, RECORDS[asked[1].kw.topic_name]);
+        answer(built.editor, built.remote, asked[2], 0, RECORDS[asked[2].kw.topic_name]);
+        expect(built.editor.priv.reload_on_open).toBe(true);
+        expect(shown).toEqual([KEPT]);
+        return built;
+    }
+
+    test("RUNS on the next edit, which is refused and said: nothing is opened on the old model", () => {
+        const {editor, remote, host} = refused_load("o1", "db/users");
+        const before = modals.length;
+        gobj_send_event(editor, "EV_EDIT_COLUMN", {col: "id"}, host);
+        expect(modals.length).toBe(before);
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+        expect(shown).toEqual([KEPT, OWED]);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(editor.priv.reload_on_open).toBe(false);
+
+        /*  Once: the next edit opens its form.  */
+        gobj_send_event(editor, "EV_EDIT_COLUMN", {col: "id"}, host);
+        expect(modals.length).toBe(before + 1);
+        expect(take("nodes")).toEqual([]);
+        expect(errors()).toEqual([]);
+        expect(not_defined()).toEqual([]);
+    });
+
+    test.each([
+        ["EV_ADD_COLUMN", {}],
+        ["EV_DUPLICATE_COLUMN", {col: "id"}],
+        ["EV_DELETE_COLUMN", {col: "id"}],
+        ["EV_MOVE_COLUMN", {from: 0, to: 1}],
+        ["EV_EXPORT", {}],
+        ["EV_IMPORT", {}],
+        ["EV_VALIDATE", {}],
+        ["EV_CONFIRMED", {what: "column", topic: "users", col: "id"}],
+    ])("%s runs it too, and writes nothing", (event, kw) => {
+        const {editor, remote, host} = refused_load(`o2_${event}`, "db/users");
+        kw = Object.assign({model_gen: editor.priv.model_gen}, kw);
+        const before = modals.length;
+        gobj_send_event(editor, event, kw, host);
+        expect(modals.length).toBe(before);
+        expect(take("update-node")).toEqual([]);
+        expect(take("delete-node")).toEqual([]);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(errors()).toEqual([]);
+        expect(not_defined()).toEqual([]);
+    });
+
+    test("a move goes where it was going, and reads the schemas there", () => {
+        const {editor, remote, host} = refused_load("o3", "db/users");
+        gobj_send_event(editor, "EV_BACK", {}, host);
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+        expect(shown).toEqual([KEPT]);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(gobj_current_state(editor)).toBe("ST_TOPICS");
+        expect(editor.priv.reload_on_open).toBe(false);
+        expect(errors()).toEqual([]);
+    });
+
+    test("keeps what this session wrote", () => {
+        const {editor, remote, host} = build("o4", "db/users");
+        const w = start_a_write(editor, host, "name");
+        answer(editor, remote, w, 0, {id: "db.users.name", value: "name", order: 2,
+            type: "string", topics: ["topics^db.users^cols"]});
+        expect(editor.priv.written).toEqual({"db.users": true});
+        editor.priv.reload_on_open = true;      /*  as a refused load leaves it  */
+        gobj_send_event(editor, "EV_ADD_COLUMN", {}, host);
+        answer_the_load(editor, remote);
+        expect(editor.priv.written).toEqual({"db.users": true});
+    });
+});
+
+describe("the import plan (fifth review)", () => {
+
+    const IMPORT = JSON.stringify({id: "db", topics: [{id: "users", pkey: "id", cols: [
+        {id: "id", type: "string", flag: ["persistent", "required"]},
+        {id: "email", type: "string"}
+    ]}]});
+
+    test("a load that could not be sent keeps it: the model it was planned on stays", () => {
+        const {editor, remote, host} = build("i1", "db");
+        gobj_send_event(editor, "EV_IMPORT", {}, host);
+        const dialog = modals[modals.length - 1];
+        gobj_send_event(editor, "EV_PREVIEW_IMPORT", {prune: false, text: IMPORT,
+            model_gen: editor.priv.model_gen}, editor);
+        const plan = editor.priv.import_plan;
+        expect(plan.writes.length).toBeGreaterThan(0);
+
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        expect(editor.priv.import_plan).toBe(plan);
+        expect(dialog.$content.querySelector(".SCHEMA_IMPORT_RUN").disabled).toBe(false);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a Yes that finds it gone is a warning, and said -- not an ERROR", () => {
+        const {editor, remote, host} = build("i2", "db");
+        gobj_send_event(editor, "EV_CONFIRMED", {what: "import",
+            model_gen: editor.priv.model_gen}, editor);
+        expect(errors()).toEqual([]);
+        expect(logged.some((l) => l.level === "warning" && /import plan is gone/.test(l.msg))).toBe(true);
+        expect(shown).toEqual(["the import plan is gone: preview it again"]);
+        expect(take("update-node")).toEqual([]);
+    });
+});
+
+describe("a confirmation answered where no treedb is open (fifth review)", () => {
+
+    test("after a reload that landed on zero treedbs: refused as stale, not NOT DEFINED", () => {
+        const {editor, remote, host} = build("e1", "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_with(editor, remote, records_with((r) => {
+            r.treedbs = [];
+            r.topics = [];
+            r.cols = [];
+        }));
+        expect(gobj_current_state(editor)).toBe("ST_EMPTY");
+        gobj_send_event(editor, "EV_CONFIRMED", kw, editor);
+        expect(not_defined()).toEqual([]);
+        expect(errors()).toEqual([]);
+        expect(shown).toEqual([STALE]);
+        expect(take("delete-node")).toEqual([]);
+    });
+
+    test("with no model at all (ST_IDLE): refused and said", () => {
+        const remote = gobj_create_service("e2_remote", "C_TEST_REMOTE", {}, yuno);
+        gobj_change_state(remote, "ST_SESSION");
+        const host = gobj_create("e2_host", "C_TEST_EDITOR_HOST", {}, yuno);
+        const editor = gobj_create("e2_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");
+        gobj_send_event(editor, "EV_CONFIRMED", {what: "column", topic: "users", col: "id",
+            model_gen: editor.priv.model_gen - 1}, editor);
+        gobj_send_event(editor, "EV_CONFIRMED", {what: "column", topic: "users", col: "id",
+            model_gen: editor.priv.model_gen}, editor);
+        expect(not_defined()).toEqual([]);
+        expect(errors()).toEqual([]);
+        expect(shown).toEqual([STALE, STALE]);
+    });
+});

package/src/shell_modals.js

@@ -278,7 +278,8 @@ export function yui_shell_show_modal(shell, content, opts)
     let modal_children;
     if(dialog) {
         let header = ["div", {class: "MODAL_HEADER yui-dialog-header"}, [
-            ["button", {class: "MODAL_BACK yui-dialog-back", type: "button", "aria-label": t("back"), "data-i18n-aria-label": "back"},
+            ["button", {class: "MODAL_BACK yui-dialog-back", type: "button", title: t("back"), "data-i18n-title": "back",
+                    "aria-label": t("back"), "data-i18n-aria-label": "back"},
                 [["i", {class: "yi-arrow-left"}]]],
             ["span", {class: "MODAL_TITLE yui-dialog-title"},
                 (title_prefix ? [["span", {class: "MODAL_TITLE_PREFIX"}, title_prefix]] : [])
@@ -504,8 +505,15 @@ function build_dialog(shell, message, buttons, opts)
         }
         let btn_attrs = {class: cls, type: "button",
                          "data-modal-button-value": b.value};
+        /*  Named by its own label key: its text is its name for the eye,
+         *  and the title and aria-label say the same to the pointer and
+         *  to a reader, re-translated with it.  */
         if(typeof b.label === "string") {
             btn_attrs.i18n = b.label;
+            btn_attrs.title = t(b.label);
+            btn_attrs["data-i18n-title"] = b.label;
+            btn_attrs["aria-label"] = t(b.label);
+            btn_attrs["data-i18n-aria-label"] = b.label;
         }
         return ["button", btn_attrs, b.label];
     });

package/src/shell_toast_once.test.js

@@ -13,7 +13,9 @@
  *
  *      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).
+ *      independent review: TOAST_CLOSE had the label only). So is
+ *      every other button of a dialog (fifth: the dialog's back arrow
+ *      had no title, and the Yes/No of every confirmation had neither).
  *
  *          Copyright (c) 2026, ArtGins.
  *          All Rights Reserved.
@@ -165,3 +167,36 @@ describe("every close control is named", () => {
         }
     });
 });
+
+describe("every other button of a dialog is named (fifth review)", () => {
+
+    function named($b)
+    {
+        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"),
+        };
+    }
+
+    test("the back arrow of an adaptive dialog", () => {
+        shell.priv.layers.modal = document.createElement("div");
+        yui_shell_show_modal(shell, document.createElement("div"), {dialog: true, title: "x"});
+        const $back = shell.priv.layers.modal.querySelector(".MODAL_BACK");
+        expect(named($back)).toEqual(
+            {title: true, title_key: "back", label: true, label_key: "back"});
+    });
+
+    test("the answers of a confirmation, named by their own label key", () => {
+        shell.priv.layers.modal = document.createElement("div");
+        yui_shell_confirm_danger(shell, "delete this column?",
+            {confirm_label: "delete", cancel_label: "cancel"});
+        const $answers = shell.priv.layers.modal.querySelectorAll(".CONFIRM_BTN");
+        expect($answers.length).toBe(2);
+        expect([...$answers].map(named)).toEqual([
+            {title: true, title_key: "delete", label: true, label_key: "delete"},
+            {title: true, title_key: "cancel", label: true, label_key: "cancel"},
+        ]);
+    });
+});