@yuneta/gobj-ui 7.26.34 → 7.26.35

package/src/treedb_json_drill.wiring.test.js

@@ -53,11 +53,13 @@ const {
 const logged = [];
 const commands = [];        /*  what the fake transport was asked  */
 let refuse_in_session = false;
+let refuse_silently = false;
 
 /*
  *  The transport. Out of session it refuses, as gui_agent's routing
  *  adapter (C_AGENT_TREEDB_LINK) does; in session it refuses only when
- *  the test says so (a transport that cannot route the command).
+ *  the test says so (a transport that cannot route the command) -- with
+ *  its words, or with a bare -1 that says nothing.
  */
 function remote_command_parser(gobj, command, kw, src)
 {
@@ -65,6 +67,9 @@ function remote_command_parser(gobj, command, kw, src)
     if(gobj_current_state(gobj) !== "ST_SESSION") {
         return `cannot route '${command}' -- not in session`;
     }
+    if(refuse_silently) {
+        return -1;
+    }
     if(refuse_in_session) {
         return `cannot route '${command}'`;
     }
@@ -148,6 +153,7 @@ beforeEach(() => {
     logged.length = 0;
     commands.length = 0;
     refuse_in_session = false;
+    refuse_silently = false;
 });
 
 /*
@@ -305,6 +311,40 @@ for(const gclass of ["C_YUI_TREEDB_TOPICS", "C_YUI_TREEDB_GRAPH"]) {
             expect(logged.filter((l) => l.level === "error")).toEqual([]);
         });
 
+        test("a failure with no word from the backend draws the fallback KEY, translated", async () => {
+            /*  "print-tranger failed" travelled as `error`, which the
+             *  viewer draws as it came: the raw key, in English, in every
+             *  language (REV-CLOUD V23.5.4). As `i18n` it is drawn with
+             *  t() and carries data-i18n, so it changes language too.  */
+            const i18next = (await import("i18next")).default;
+            i18next.addResourceBundle("en", "translation",
+                {"print-tranger failed": "the tranger could not be read"}, true, true);
+            const {remote, host, viewer} = build(`${gclass}_i`, gclass);
+            click_stub(viewer);
+            const request = commands.find((c) => c.command === "print-tranger");
+            gobj_send_event(host, "EV_MT_COMMAND_ANSWER", {
+                result: -1, comment: "", data: null,
+                __md_iev__: {
+                    command_stack: [{command: "print-tranger", kw: request.kw.__md_command__}]
+                }
+            }, remote);
+            expect(viewer.priv.errors.get("topics")).toEqual(
+                {error: "print-tranger failed", is_key: true});
+            const $err = viewer.priv.$tree.querySelector(".JSON_STUB_ERR");
+            expect($err.getAttribute("data-i18n")).toBe("print-tranger failed");
+            expect($err.textContent).toBe("the tranger could not be read");
+        });
+
+        test("a refusal of the transport that says nothing draws the fallback KEY too", () => {
+            const {viewer} = build(`${gclass}_j`, gclass);
+            refuse_silently = true;
+            click_stub(viewer);
+            expect(drills()).toEqual(["topics"]);
+            expect(viewer.priv.pending.has("topics")).toBe(false);
+            expect(viewer.priv.errors.get("topics")).toEqual(
+                {error: "print-tranger failed", is_key: true});
+        });
+
         test("a drill that failed is not answered again by a drop", () => {
             const {remote, host, viewer} = build(`${gclass}_f`, gclass);
             click_stub(viewer);

package/src/window_layer.wiring.test.js

@@ -2,15 +2,26 @@
  *          window_layer.wiring.test.js
  *
  *      Where a C_YUI_WINDOW lives when its host names no `$parent`:
- *      the OVERLAY layer of the shell, below the layers of the
- *      dropdowns, the dialogs and the toasts -- not document.body,
- *      where it covered the whole shell (a stacking context of its
- *      own) and the dialog of its own close opened under it.
+ *      the WINDOW layer of the shell, a stacking context inside the
+ *      overlay layer, below the drawer, the dropdowns, the dialogs and
+ *      the toasts -- not document.body, where it covered the whole
+ *      shell (a stacking context of its own) and the dialog of its own
+ *      close opened under it.
+ *
+ *      And that the place FOLLOWS the shell (REV-CLOUD V23.3): a window
+ *      parented to the app outlives a logout that destroys the shell.
+ *      From 7.26.31 to 7.26.34 it stayed in the destroyed shell's layer,
+ *      alive and detached, and the next shell never placed it again: the
+ *      developer window of gui_agent, gui_treedb and wattyzer vanished
+ *      after a logout and a login. The dock, the same.
  *
  *          Copyright (c) 2026, ArtGins.
  *          All Rights Reserved.
  ***********************************************************************/
-import {describe, test, expect, beforeAll} from "vitest";
+import {describe, test, expect, beforeAll, beforeEach} from "vitest";
+import {readFileSync} from "node:fs";
+import {dirname, join} from "node:path";
+import {fileURLToPath} from "node:url";
 import {install_dom_double} from "../test/dom_double.js";
 
 install_dom_double();
@@ -22,18 +33,27 @@ if(typeof globalThis.matchMedia === "undefined") {
 const {
     SDATA, SDATA_END, data_type_t, gclass_create, gobj_write_attr,
     gobj_start_up, gobj_create_yuno, gobj_create, gobj_create_service,
-    gobj_start, gobj_stop, gobj_destroy, gobj_read_attr,
+    gobj_start, gobj_stop, gobj_destroy, gobj_read_attr, gobj_is_destroying,
+    set_log_callback,
 } = await import("@yuneta/gobj-js");
-const {register_c_yui_shell} = await import("./c_yui_shell.js");
+const {register_c_yui_shell, yui_shell_window_layer} = await import("./c_yui_shell.js");
 const {register_c_yui_nav} = await import("./c_yui_nav.js");
 const {register_c_yui_window} = await import("./c_yui_window.js");
+const {register_c_yui_window_manager} = await import("./c_yui_window_manager.js");
+
+const SRC = dirname(fileURLToPath(import.meta.url));
 
+const logged = [];
 let yuno = null;
+let seq = 0;
 
 beforeAll(async () => {
     const i18next = (await import("i18next")).default;
     await i18next.init({lng: "en", resources: {}});
     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_LAYER_HOST", [], [["ST_IDLE", []]], {}, 0, [SDATA_END()], {}, 0, 0, 0, 0);
     gclass_create(
         "C_TEST_LAYER_VIEW", [], [["ST_IDLE", []]], {
@@ -48,59 +68,304 @@ beforeAll(async () => {
     register_c_yui_shell();
     register_c_yui_nav();
     register_c_yui_window();
+    register_c_yui_window_manager();
     yuno = gobj_create_yuno("layer_yuno", "C_TEST_LAYER_HOST", {});
     gobj_start(yuno);
 });
 
+beforeEach(() => {
+    logged.length = 0;
+});
+
+function errors()
+{
+    return logged.filter((l) => l.level === "error").map((l) => l.msg);
+}
+
+/*  A shell with one routed view, as an app builds it at login.  */
+function build_shell(opts)
+{
+    const shell = gobj_create(`layer_shell_${++seq}`, "C_YUI_SHELL", Object.assign({
+        config: {
+            shell: {
+                zones: {center: {host: "stage.main"}},
+                stages: {main: {zone: "center", default_route: "/a"}}
+            },
+            menu: {primary: {items: [
+                {id: "a", name: "a", route: "/a",
+                 target: {stage: "main", gclass: "C_TEST_LAYER_VIEW", kw: {}}}
+            ]}}
+        },
+        use_hash: false
+    }, opts || {}), yuno);
+    gobj_start(shell);
+    return shell;
+}
+
+/*  What an app does at logout (gui_agent's destroy_shell()).  */
+function logout(shell)
+{
+    gobj_stop(shell);
+    gobj_destroy(shell);
+}
+
+function open_window(name, kw, parent)
+{
+    const w = gobj_create_service(name, "C_YUI_WINDOW",
+        Object.assign({header: name, body: ["div", {}, name]}, kw || {}), parent || yuno);
+    gobj_start(w);
+    return w;
+}
+
+function close(w)
+{
+    gobj_stop(w);
+    gobj_destroy(w);
+}
+
+/*  Identity, asked as a boolean: a failing toBe() over a DOM double
+ *  makes vitest pretty-print it, and the double has no attribute list.  */
+function lives_in(w, $place)
+{
+    return gobj_read_attr(w, "$container").parentNode === $place;
+}
+
+function on_page(w)
+{
+    return document.documentElement.contains(gobj_read_attr(w, "$container"));
+}
+
 describe("the default parent of a window", () => {
     test("with no shell: document.body", () => {
-        const w = gobj_create_service("layer_w0", "C_YUI_WINDOW", {header: "w", body: ["div", {}, "w"]}, yuno);
-        gobj_start(w);
-        expect(gobj_read_attr(w, "$container").parentNode).toBe(document.body);
-        gobj_stop(w);
-        gobj_destroy(w);
+        const w = open_window("layer_w0");
+        expect(lives_in(w, document.body)).toBe(true);
+        close(w);
     });
 
-    test("with a shell: its overlay layer, also for a window that is not its child", () => {
-        const shell = gobj_create("layer_shell", "C_YUI_SHELL", {
-            config: {
-                shell: {
-                    zones: {center: {host: "stage.main"}},
-                    stages: {main: {zone: "center", default_route: "/a"}}
-                },
-                menu: {primary: {items: [
-                    {id: "a", name: "a", route: "/a",
-                     target: {stage: "main", gclass: "C_TEST_LAYER_VIEW", kw: {}}}
-                ]}}
-            },
-            use_hash: false
-        }, yuno);
-        gobj_start(shell);
+    test("with a shell: its window layer, inside the overlay layer, also for a window that is not its child", () => {
+        const shell = build_shell();
 
         /*  A child of the shell, and one parented to the app (the dev
-         *  window, a device window of a view): both in the overlay.  */
-        const inside = gobj_create_service("layer_w1", "C_YUI_WINDOW", {header: "a", body: ["div", {}, "a"]}, shell);
-        gobj_start(inside);
-        const outside = gobj_create_service("layer_w2", "C_YUI_WINDOW", {header: "b", body: ["div", {}, "b"]}, yuno);
-        gobj_start(outside);
+         *  window, a device window of a view): both in the window layer.  */
+        const inside = open_window("layer_w1", {}, shell);
+        const outside = open_window("layer_w2");
 
         const overlay = shell.priv.layers.overlay;
-        expect(overlay).toBeTruthy();
-        expect(gobj_read_attr(inside, "$container").parentNode).toBe(overlay);
-        expect(gobj_read_attr(outside, "$container").parentNode).toBe(overlay);
+        const windows = yui_shell_window_layer(shell);
+        expect(!!overlay).toBe(true);
+        expect(windows.parentNode === overlay).toBe(true);
+        expect(windows.classList.contains("SHELL_WINDOW_LAYER")).toBe(true);
+        expect(lives_in(inside, windows)).toBe(true);
+        expect(lives_in(outside, windows)).toBe(true);
 
         /*  And a `$parent` named by the host still wins.  */
         const $mine = document.createElement("div");
-        const named = gobj_create_service("layer_w3", "C_YUI_WINDOW",
-            {header: "c", body: ["div", {}, "c"], $parent: $mine}, yuno);
-        gobj_start(named);
-        expect(gobj_read_attr(named, "$container").parentNode).toBe($mine);
+        const named = open_window("layer_w3", {$parent: $mine});
+        expect(lives_in(named, $mine)).toBe(true);
 
         for(const w of [inside, outside, named]) {
-            gobj_stop(w);
-            gobj_destroy(w);
+            close(w);
         }
-        gobj_stop(shell);
-        gobj_destroy(shell);
+        logout(shell);
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("a window outlives its shell (logout, then login)", () => {
+    test("it goes to the body with the shell, and the next shell takes it in", () => {
+        const shell1 = build_shell();
+        const dev = open_window("layer_dev");       /*  parented to the app  */
+        expect(lives_in(dev, yui_shell_window_layer(shell1))).toBe(true);
+
+        /*  Logout: the shell and its layers go, the window does not.  */
+        logout(shell1);
+        expect(gobj_is_destroying(dev)).toBe(false);
+        expect(lives_in(dev, document.body)).toBe(true);
+        expect(on_page(dev)).toBe(true);
+
+        /*  Login: a new shell, and the window in it, on the page.  */
+        const shell2 = build_shell();
+        expect(lives_in(dev, yui_shell_window_layer(shell2))).toBe(true);
+        expect(on_page(dev)).toBe(true);
+
+        close(dev);
+        logout(shell2);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a window created before any shell is taken in by the first one", () => {
+        const early = open_window("layer_early");
+        expect(lives_in(early, document.body)).toBe(true);
+
+        const shell = build_shell();
+        expect(lives_in(early, yui_shell_window_layer(shell))).toBe(true);
+
+        close(early);
+        logout(shell);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a window its host placed stays there; one whose place went with the shell takes the window place", () => {
+        const shell1 = build_shell();
+
+        /*  Placed by its host in an element of the page: never moved.  */
+        const $mine = document.createElement("div");
+        document.body.appendChild($mine);
+        const placed = open_window("layer_placed", {$parent: $mine});
+
+        /*  Placed by its host INSIDE the shell (a layer of it), but not
+         *  its child: the place goes with the shell, the window does not.  */
+        const $popup = shell1.priv.layers.popup;
+        const stranded = open_window("layer_stranded", {$parent: $popup});
+
+        logout(shell1);
+        expect(lives_in(placed, $mine)).toBe(true);
+        expect(lives_in(stranded, document.body)).toBe(true);
+
+        const shell2 = build_shell();
+        expect(lives_in(placed, $mine)).toBe(true);
+        expect(lives_in(stranded, yui_shell_window_layer(shell2))).toBe(true);
+
+        close(placed);
+        close(stranded);
+        $mine.remove();
+        logout(shell2);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a child of the shell goes with it, and nobody is told about it later", () => {
+        const shell1 = build_shell();
+        const child = open_window("layer_child", {}, shell1);
+        logout(shell1);
+        expect(gobj_is_destroying(child)).toBe(true);
+
+        /*  The next shell tells only the live ones: no event to a dead
+         *  window, no "destroyed gobj still watches".  */
+        const shell2 = build_shell();
+        logout(shell2);
+        expect(errors()).toEqual([]);
+    });
+
+    test("its Back entry goes with the shell that held it", () => {
+        const shell1 = build_shell({use_hash: true});
+        const floating = open_window("layer_back");
+        expect(!!gobj_read_attr(floating, "back_overlay")).toBe(true);
+
+        logout(shell1);
+        expect(gobj_read_attr(floating, "back_overlay")).toBe(null);
+
+        /*  The next shell holds no entry of it, and closing it retires
+         *  nothing there.  */
+        const shell2 = build_shell({use_hash: true});
+        expect(shell2.priv.overlay_stack.length).toBe(0);
+        close(floating);
+        expect(shell2.priv.overlay_stack.length).toBe(0);
+        logout(shell2);
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("the dock follows the shell", () => {
+    test("a floating dock lives in the shell's popup layer, under the dialogs; in the body while there is none", () => {
+        const dock = gobj_create_service("layer_dock1", "C_YUI_WINDOW_MANAGER", {}, yuno);
+        gobj_start(dock);
+        const $dock = gobj_read_attr(dock, "$container");
+        expect($dock.parentNode === document.body).toBe(true);
+
+        const shell1 = build_shell();
+        expect($dock.parentNode === shell1.priv.layers.popup).toBe(true);
+
+        logout(shell1);
+        expect($dock.parentNode === document.body).toBe(true);
+
+        const shell2 = build_shell();
+        expect($dock.parentNode === shell2.priv.layers.popup).toBe(true);
+
+        gobj_stop(dock);
+        gobj_destroy(dock);
+        logout(shell2);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a docked window survives a logout, and its chip still brings it back", () => {
+        const dock = gobj_create_service("layer_dock2", "C_YUI_WINDOW_MANAGER", {}, yuno);
+        gobj_start(dock);
+        const shell1 = build_shell();
+        const dev = open_window("layer_docked", {manager: dock});
+        const $win = gobj_read_attr(dev, "$container");
+        expect(lives_in(dev, yui_shell_window_layer(shell1))).toBe(true);
+
+        logout(shell1);
+        const shell2 = build_shell();
+        expect(lives_in(dev, yui_shell_window_layer(shell2))).toBe(true);
+        expect(on_page(dev)).toBe(true);
+
+        /*  Its chip is still in the dock, and the dock on the page: a
+         *  press of its toggle minimises it, another one brings it back
+         *  on top.  */
+        const $toggle = gobj_read_attr(dock, "$container").querySelector(".DOCK_CHIP_TOGGLE");
+        expect(!!$toggle).toBe(true);
+        expect(document.documentElement.contains($toggle)).toBe(true);
+        $toggle.click();
+        expect($win.style.display).toBe("none");
+        $toggle.click();
+        expect($win.style.display).toBe(undefined);
+        expect(Number($win.style.zIndex) > 10).toBe(true);
+
+        close(dev);
+        gobj_stop(dock);
+        gobj_destroy(dock);
+        logout(shell2);
+        expect(errors()).toEqual([]);
+    });
+
+    test("an inline dock moves to the next shell's zone, and floats in the body between them", () => {
+        const dock = gobj_create_service("layer_dock3", "C_YUI_WINDOW_MANAGER", {
+            dock_mode: "inline",
+            inline_selector: '[data-zone="bottom-sub"]'
+        }, yuno);
+        gobj_start(dock);
+        const $dock = gobj_read_attr(dock, "$container");
+
+        const shell1 = build_shell();
+        expect($dock.parentNode === shell1.priv.zones["bottom-sub"]).toBe(true);
+
+        logout(shell1);
+        expect($dock.parentNode === document.body).toBe(true);
+        expect($dock.classList.contains("yui-dock--floating")).toBe(true);
+
+        const shell2 = build_shell();
+        expect($dock.parentNode === shell2.priv.zones["bottom-sub"]).toBe(true);
+        expect($dock.classList.contains("yui-dock--inline")).toBe(true);
+
+        gobj_stop(dock);
+        gobj_destroy(dock);
+        logout(shell2);
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("the stacking of the windows", () => {
+    /*  The z-index a window takes from the dock grows on every focus.
+     *  In the overlay layer itself it competed with the drawer (18):
+     *  after a few focus changes a new drawer opened UNDER the windows.
+     *  The window layer is a stacking context below the drawer, so no
+     *  number a window takes reaches it. CSS, read as text: the double
+     *  has no layout.  */
+    test("the window layer is a stacking context under the drawer", () => {
+        const css = readFileSync(join(SRC, "c_yui_shell.css"), "utf8");
+        const rule = (selector) => {
+            const m = css.match(new RegExp(selector + "\\s*\\{([^}]*)\\}"));
+            return m? m[1] : "";
+        };
+        const z_of = (body) => {
+            const m = body.match(/z-index:\s*(\d+)/);
+            return m? Number(m[1]) : NaN;
+        };
+        const windows = rule("\\.yui-layer > \\.yui-window-layer");
+        const drawer = rule("\\.yui-drawer");
+        expect(windows).toMatch(/position:\s*absolute/);
+        expect(windows).toMatch(/pointer-events:\s*none/);
+        expect(z_of(windows) < z_of(drawer)).toBe(true);
     });
 });

package/src/window_show.wiring.test.js

@@ -51,17 +51,21 @@ function errors()
 }
 
 describe("EV_SHOW", () => {
-    test("without a dock: a hidden window is shown, and goes on top of its layer", () => {
+    test("without a dock: a hidden window is shown, and goes on top of the others", () => {
         const a = gobj_create_service("show_a", "C_YUI_WINDOW", {header: "a", body: ["div", {}, "a"]}, yuno);
         gobj_start(a);
         const b = gobj_create_service("show_b", "C_YUI_WINDOW", {header: "b", body: ["div", {}, "b"]}, yuno);
         gobj_start(b);
         const $a = gobj_read_attr(a, "$container");
+        const $b = gobj_read_attr(b, "$container");
         $a.style.setProperty("display", "none", "important");
 
         gobj_send_event(a, "EV_SHOW", {}, yuno);
         expect($a.style.getPropertyValue("display")).toBe("");
-        expect($a.parentNode.lastChild).toBe($a);
+        /*  On top by the windows' one z-order (yui_shell_raise_window),
+         *  not by being moved in the DOM: a move takes its focus and the
+         *  press that started on it.  */
+        expect(Number($a.style.zIndex) > Number($b.style.zIndex)).toBe(true);
         expect(errors()).toEqual([]);
     });