@yuneta/gobj-ui 7.25.15 → 7.25.16

package/src/schema_editor_reload.wiring.test.js

@@ -316,6 +316,8 @@ 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 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 OWED_FORM = "the schemas shown may be out of date: they are read again, and the form opens again on them with your changes";
+const GONE = "the schemas were read again and what the form was editing is not there any more";
 const NOT_SENT = "the treedb did not describe a write back: the writes after it were not sent";
 
 describe("the screen of a reload", () => {
@@ -618,6 +620,7 @@ describe("a load that fails IN session", () => {
         const {editor, remote, host} = build("b1", "db/users");
         gobj_send_event(editor, "EV_EDIT_COLUMN", {col: "id"}, host);
         const form = modals[modals.length - 1];
+        form.$content.querySelector('[data-name="header"]').value = "Identifier";
         gobj_send_event(editor, "EV_REFRESH", {}, host);
         const asked = take("nodes");
         answer(editor, remote, asked[0], -1, null, "deadline");
@@ -634,16 +637,28 @@ describe("a load that fails IN session", () => {
 
         /*  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, and the load that lands
-         *  closes the form.  */
+         *  reload owed instead. The load that lands closes the form,
+         *  and opens it again ON THE SCHEMAS JUST READ with what the
+         *  operator changed: closed alone, what was typed was lost.  */
         form.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
         expect(not_defined()).toEqual([]);
         expect(take("update-node")).toEqual([]);
-        expect(shown).toEqual([KEPT, OWED]);
+        expect(shown).toEqual([KEPT, OWED_FORM]);
+        const before = modals.length;
         expect(answer_the_load(editor, remote)).toBe(3);
         expect(form.closed).toBe(true);
-        expect(shown).toEqual([KEPT, OWED, STALE]);
+        expect(modals.length).toBe(before + 1);
+        const again = modals[modals.length - 1];
+        expect(again.closed).toBe(false);
+        expect(again.$content.querySelector('[data-name="header"]').value).toBe("Identifier");
+        expect(shown).toEqual([KEPT, OWED_FORM]);
         expect(editor.priv.reload_on_open).toBe(false);
+
+        /*  Its Save writes, on the record just read.  */
+        again.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
+        const [write] = take("update-node");
+        expect(write.kw.record.id).toBe("db.users.id");
+        expect(write.kw.record.header).toBe("Identifier");
         expect(errors()).toEqual([]);
     });
 
@@ -1353,3 +1368,136 @@ describe("a move sent by the host while a dialog is up", () => {
         expect(shown).toEqual([]);
     });
 });
+
+describe("the form opened again after the owed reload", () => {
+
+    function owing(name, subpath)
+    {
+        const built = build(name, subpath);
+        built.editor.priv.reload_on_open = true;    /*  as a load refused in session leaves it  */
+        return built;
+    }
+
+    test("only what was CHANGED is carried: a field the store changed meanwhile shows the store's", () => {
+        const {editor, remote, host} = build("ro6", "db/users");
+        gobj_send_event(editor, "EV_EDIT_COLUMN", {col: "id"}, host);
+        editor.priv.reload_on_open = true;
+        const form = modals[modals.length - 1];
+        form.$content.querySelector('[data-name="header"]').value = "Identifier";
+        form.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
+        answer_the_load_with(editor, remote, records_with((r) => {
+            r.cols[0].description = "written by somebody else";
+        }));
+        const again = modals[modals.length - 1];
+        expect(again.$content.querySelector('[data-name="header"]').value).toBe("Identifier");
+        expect(again.$content.querySelector('[data-name="description"]').value)
+            .toBe("written by somebody else");
+        again.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
+        const [write] = take("update-node");
+        expect(write.kw.record.description).toBe("written by somebody else");
+        expect(write.kw.record.header).toBe("Identifier");
+        expect(errors()).toEqual([]);
+    });
+
+    test("a NEW column comes back whole: its name, its type and its flags", () => {
+        const {editor, remote, host} = owing("ro2", "db/users");
+        /*  The owed reload runs on the form's opening too: open it on a
+         *  model that is current, then owe the reload.  */
+        editor.priv.reload_on_open = false;
+        gobj_send_event(editor, "EV_ADD_COLUMN", {}, host);
+        editor.priv.reload_on_open = true;
+        const form = modals[modals.length - 1];
+        form.$content.querySelector('[data-name="value"]').value = "email";
+        form.$content.querySelector('[data-name="header"]').value = "Email";
+        for(const $box of form.$content.querySelectorAll(".SCHEMA_FLAG_BOX")) {
+            if($box.dataset.flag === "required") {
+                $box.checked = true;
+            }
+        }
+        form.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
+        expect(shown).toEqual([OWED_FORM]);
+        answer_the_load(editor, remote);
+        const again = modals[modals.length - 1];
+        expect(again).not.toBe(form);
+        expect(again.$content.querySelector('[data-name="value"]').value).toBe("email");
+        expect(again.$content.querySelector('[data-name="header"]').value).toBe("Email");
+        const on = [...again.$content.querySelectorAll(".SCHEMA_FLAG_BOX")]
+            .filter(($b) => $b.checked).map(($b) => $b.dataset.flag);
+        expect(on).toContain("required");
+        expect(errors()).toEqual([]);
+    });
+
+    test("a topic form comes back the same way", () => {
+        const {editor, remote, host} = build("ro3", "db");
+        gobj_send_event(editor, "EV_EDIT_TOPIC", {topic: "users"}, host);
+        editor.priv.reload_on_open = true;
+        const form = modals[modals.length - 1];
+        form.$content.querySelector('[data-name="tkey"]').value = "tm";
+        form.$content.querySelector(".SCHEMA_TOPIC_FORM_SAVE").click();
+        expect(shown).toEqual([OWED_FORM]);
+        answer_the_load(editor, remote);
+        const again = modals[modals.length - 1];
+        expect(again).not.toBe(form);
+        expect(again.$content.querySelector('[data-name="tkey"]').value).toBe("tm");
+        expect(errors()).toEqual([]);
+    });
+
+    test("what the form edited is gone after the reload: not opened again, and SAID", () => {
+        const {editor, remote, host} = build("ro4", "db/users");
+        gobj_send_event(editor, "EV_EDIT_COLUMN", {col: "id"}, host);
+        editor.priv.reload_on_open = true;
+        const form = modals[modals.length - 1];
+        form.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
+        const before = modals.length;
+        answer_the_load_with(editor, remote, records_with((r) => {
+            r.cols = [];
+        }));
+        expect(form.closed).toBe(true);
+        expect(modals.length).toBe(before);
+        expect(shown).toEqual([OWED_FORM, GONE]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a form closed by the operator while the reload ran is not opened again", () => {
+        const {editor, remote, host} = build("ro5", "db/users");
+        gobj_send_event(editor, "EV_EDIT_COLUMN", {col: "id"}, host);
+        editor.priv.reload_on_open = true;
+        const form = modals[modals.length - 1];
+        form.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
+        form.$content.querySelector(".SCHEMA_COL_FORM_CANCEL").click();
+        const before = modals.length;
+        answer_the_load(editor, remote);
+        expect(modals.length).toBe(before);
+        expect(shown).toEqual([OWED_FORM]);
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("EV_REFRESH while a write is in flight", () => {
+
+    test("waits for the end of the writes: the queue is written whole, then the schemas are read", () => {
+        const {editor, remote, host} = build("rq1", "db");
+        gobj_send_event(editor, "EV_CONFIRMED", {what: "topic", topic: "users",
+            model_gen: editor.priv.model_gen}, editor);
+        expect(gobj_current_state(editor)).toBe("ST_SAVING");
+        const [first] = take("delete-node");
+        expect(first.kw.topic_name).toBe("cols");
+
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        expect(gobj_current_state(editor)).toBe("ST_SAVING");
+        expect(take("nodes")).toEqual([]);
+        expect(logged.some((l) => l.level === "warning" &&
+            /EV_REFRESH.*when the writes end/.test(l.msg))).toBe(true);
+
+        answer(editor, remote, first, 0, {});
+        const [second] = take("delete-node");
+        expect(second.kw.topic_name).toBe("topics");
+        answer(editor, remote, second, 0, {});
+
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(editor.priv.written).toEqual({});
+        expect(errors()).toEqual([]);
+        expect(not_defined()).toEqual([]);
+    });
+});

package/src/shell_modals.js

@@ -613,9 +613,30 @@ function build_dialog(shell, message, buttons, opts)
 }
 
 
+/***************************************************************
+ *  The labels a confirmation shows when the caller names none.
+ *
+ *  They are i18n KEYS, lower-case like every key: a button
+ *  translates its label with the app's t() -- its text, its title
+ *  and its aria-label. Until 7.25.16 they were "OK", "Yes", "No",
+ *  "Delete" and "Cancel", keys that no locale carries, so a dialog
+ *  that took the defaults read in English in every language.
+ *
+ *  Written as `i18n:` entries so the validate-locales script of a
+ *  consumer finds them when it scans this module: an app that
+ *  mounts these dialogs must define the five keys.
+ ***************************************************************/
+const DEFAULT_LABEL = Object.freeze({
+    ok:     Object.freeze({i18n: "ok"}),
+    yes:    Object.freeze({i18n: "yes"}),
+    no:     Object.freeze({i18n: "no"}),
+    delete: Object.freeze({i18n: "delete"}),
+    cancel: Object.freeze({i18n: "cancel"})
+});
+
 export function yui_shell_confirm_ok(shell, message, opts)
 {
-    let label = (opts && opts.ok_label) || "OK";
+    let label = (opts && opts.ok_label) || DEFAULT_LABEL.ok.i18n;
     if(!opts || !opts.type) {
         opts = Object.assign({}, opts, {type: "success"});
     }
@@ -626,8 +647,8 @@ export function yui_shell_confirm_ok(shell, message, opts)
 
 export function yui_shell_confirm_yesno(shell, message, opts)
 {
-    let yes_label = (opts && opts.yes_label) || "Yes";
-    let no_label  = (opts && opts.no_label)  || "No";
+    let yes_label = (opts && opts.yes_label) || DEFAULT_LABEL.yes.i18n;
+    let no_label  = (opts && opts.no_label)  || DEFAULT_LABEL.no.i18n;
     return build_dialog(shell, message, [
         {label: yes_label, value: "yes", kind: "primary"},
         {label: no_label,  value: "no"}
@@ -650,8 +671,8 @@ export function yui_shell_confirm_yesno(shell, message, opts)
  ***************************************************************/
 export function yui_shell_confirm_danger(shell, message, opts)
 {
-    let confirm_label = (opts && opts.confirm_label) || "Delete";
-    let cancel_label  = (opts && opts.cancel_label)  || "Cancel";
+    let confirm_label = (opts && opts.confirm_label) || DEFAULT_LABEL.delete.i18n;
+    let cancel_label  = (opts && opts.cancel_label)  || DEFAULT_LABEL.cancel.i18n;
     if(!opts || !opts.type) {
         opts = Object.assign({}, opts, {type: "danger"});
     }
@@ -663,9 +684,9 @@ export function yui_shell_confirm_danger(shell, message, opts)
 
 export function yui_shell_confirm_yesnocancel(shell, message, opts)
 {
-    let yes_label    = (opts && opts.yes_label)    || "Yes";
-    let no_label     = (opts && opts.no_label)     || "No";
-    let cancel_label = (opts && opts.cancel_label) || "Cancel";
+    let yes_label    = (opts && opts.yes_label)    || DEFAULT_LABEL.yes.i18n;
+    let no_label     = (opts && opts.no_label)     || DEFAULT_LABEL.no.i18n;
+    let cancel_label = (opts && opts.cancel_label) || DEFAULT_LABEL.cancel.i18n;
     return build_dialog(shell, message, [
         {label: yes_label,    value: "yes", kind: "primary"},
         {label: no_label,     value: "no"},

package/src/shell_toast_once.test.js

@@ -30,6 +30,9 @@ const {
     yui_shell_show_info,
     yui_shell_show_modal,
     yui_shell_confirm_danger,
+    yui_shell_confirm_ok,
+    yui_shell_confirm_yesno,
+    yui_shell_confirm_yesnocancel,
 } = await import("./shell_modals.js");
 
 let shell = null;
@@ -200,3 +203,63 @@ describe("every other button of a dialog is named", () => {
         ]);
     });
 });
+
+/*
+ *  A confirmation that names no label shows the DEFAULT ones, and those
+ *  are i18n keys like every other label: lower-case, translated by the
+ *  app's t(), and carried as the key of the text, the title and the
+ *  aria-label. They were "OK", "Yes", "No", "Delete" and "Cancel" --
+ *  keys no locale has, so the button read in English in every language.
+ */
+describe("the default labels of a confirmation are i18n keys", () => {
+
+    function keys_of($layer)
+    {
+        return [...$layer.querySelectorAll(".CONFIRM_BTN")].map(($b) => [
+            $b.getAttribute("data-i18n"),
+            $b.getAttribute("data-i18n-title"),
+            $b.getAttribute("data-i18n-aria-label"),
+        ]);
+    }
+
+    /*  What the reader hears: the aria-label, translated by t() when
+     *  the button is built.  */
+    function texts_of($layer)
+    {
+        return [...$layer.querySelectorAll(".CONFIRM_BTN")].map(($b) => $b.getAttribute("aria-label"));
+    }
+
+    const k = (key) => [key, key, key];
+
+    /*  A translator that tells a key it knows from one it does not.  */
+    const ES = {ok: "Aceptar", yes: "Sí", no: "No", delete: "Borrar", cancel: "Cancelar"};
+    const t = (key) => ES[key] || `?${key}?`;
+
+    test("ok", () => {
+        shell.priv.layers.modal = document.createElement("div");
+        yui_shell_confirm_ok(shell, "saved", {t: t});
+        expect(keys_of(shell.priv.layers.modal)).toEqual([k("ok")]);
+        expect(texts_of(shell.priv.layers.modal)).toEqual(["Aceptar"]);
+    });
+
+    test("yes / no", () => {
+        shell.priv.layers.modal = document.createElement("div");
+        yui_shell_confirm_yesno(shell, "go on?", {t: t});
+        expect(keys_of(shell.priv.layers.modal)).toEqual([k("yes"), k("no")]);
+        expect(texts_of(shell.priv.layers.modal)).toEqual(["Sí", "No"]);
+    });
+
+    test("yes / no / cancel", () => {
+        shell.priv.layers.modal = document.createElement("div");
+        yui_shell_confirm_yesnocancel(shell, "keep it?", {t: t});
+        expect(keys_of(shell.priv.layers.modal)).toEqual([k("yes"), k("no"), k("cancel")]);
+        expect(texts_of(shell.priv.layers.modal)).toEqual(["Sí", "No", "Cancelar"]);
+    });
+
+    test("delete / cancel", () => {
+        shell.priv.layers.modal = document.createElement("div");
+        yui_shell_confirm_danger(shell, "delete this column?", {t: t});
+        expect(keys_of(shell.priv.layers.modal)).toEqual([k("delete"), k("cancel")]);
+        expect(texts_of(shell.priv.layers.modal)).toEqual(["Borrar", "Cancelar"]);
+    });
+});

package/src/table_cell_text.test.js

@@ -9,7 +9,7 @@ const doc = {
 describe("table_cell_text", () => {
 
     it("record text is a text node, markup included", () => {
-        /*  M31: Tabulator puts a string through innerHTML  */
+        /*  Tabulator puts a string through innerHTML  */
         const node = cell_text("limit a<b and c>d", doc);
         expect(node.nodeType).toBe(3);
         expect(node.textContent).toBe("limit a<b and c>d");

package/src/treedb_topics_transport.wiring.test.js

@@ -169,7 +169,7 @@ function errors()
     return logged.filter((l) => l.level === "error").map((l) => l.msg);
 }
 
-describe("a Save in flight when the backend drops (M8)", () => {
+describe("a Save in flight when the backend drops", () => {
 
     test("the shell's connection edge answers every form, with no host forwarding", () => {
         const {shell, topics, forms} = build("t1");

package/src/yui_install.js

@@ -194,6 +194,17 @@ function yui_install_start_watch()
  *      app can call yui_install_prompt() from a button of its
  *      own whenever it likes.
  ***************************************************************/
+/*  The question and its answers when the app names none. They are i18n
+ *  KEYS, lower-case, and the ones every consumer already defines; the
+ *  question was "Install this app?" until 7.25.16, a key no locale
+ *  carries. Written as `i18n:` entries so the validate-locales script of
+ *  a consumer finds them when it scans this module.  */
+const DEFAULT_ASK = Object.freeze({
+    message: Object.freeze({i18n: "install this app"}),
+    yes:     Object.freeze({i18n: "install"}),
+    no:      Object.freeze({i18n: "not now"})
+});
+
 function yui_install_ask_once(shell, opts)
 {
     opts = opts || {};
@@ -213,10 +224,10 @@ function yui_install_ask_once(shell, opts)
         S.asking = true;
         kw_set_local_storage_value(ASKED_KEY, true);
 
-        yui_shell_confirm_yesno(shell, opts.message || "Install this app?", {
+        yui_shell_confirm_yesno(shell, opts.message || DEFAULT_ASK.message.i18n, {
             t:         opts.t,
-            yes_label: opts.yes_label || "install",
-            no_label:  opts.no_label  || "not now"
+            yes_label: opts.yes_label || DEFAULT_ASK.yes.i18n,
+            no_label:  opts.no_label  || DEFAULT_ASK.no.i18n
         }).then(function(yes) {
             S.asking = false;
             if(yes) {

package/src/yui_install.test.js

@@ -140,3 +140,26 @@ test("subscribe(): a throwing listener does not break the others", async () => {
     off1();
     off2();
 });
+
+/*  The question asked when the app names none is an i18n KEY, the one
+ *  every consumer already defines ("install this app"). It was
+ *  "Install this app?", a key no locale carries, so an app that took
+ *  the default asked in English in every language.  */
+test("ask_once(): the default question and answers are i18n keys", async () => {
+    const asked = [];
+    vi.resetModules();
+    vi.doMock("./shell_modals.js", () => ({
+        yui_shell_confirm_yesno: (shell, message, opts) => {
+            asked.push({message, yes: opts.yes_label, no: opts.no_label});
+            return new Promise(() => {});
+        }
+    }));
+    try {
+        const {yui_install_ask_once} = await import("./yui_install.js");
+        window[STASH] = fake_event("accepted");
+        yui_install_ask_once({fake_shell: true}, {});
+        expect(asked).toEqual([{message: "install this app", yes: "install", no: "not now"}]);
+    } finally {
+        vi.doUnmock("./shell_modals.js");
+    }
+});