@yuneta/gobj-ui 7.25.1 → 7.25.3

package/src/form_busy.test.js

@@ -0,0 +1,84 @@
+import {describe, it, expect} from "vitest";
+import {set_toolbar_busy} from "./form_busy.js";
+
+/*  A toolbar double: the two things the helper touches on a button are
+ *  `disabled` and `dataset`, and on the save button its class list.  */
+function button(cls, disabled)
+{
+    const classes = new Set(cls.split(" "));
+    return {
+        disabled: disabled,
+        dataset: {},
+        classList: {
+            toggle: (c, on) => {
+                if(on) {
+                    classes.add(c);
+                } else {
+                    classes.delete(c);
+                }
+            },
+            contains: (c) => classes.has(c),
+        },
+    };
+}
+
+function toolbar()
+{
+    const save = button("button-save", false);
+    const cancel = button("button-cancel", false);
+    const undo = button("button-undo", true);     /*  disabled on its own  */
+    const buttons = [save, cancel, undo];
+    return {
+        save, cancel, undo,
+        $container: {
+            querySelectorAll: () => buttons,
+            querySelector: () => save,
+        },
+    };
+}
+
+describe("set_toolbar_busy", () => {
+
+    it("busy then free: every button is as it was", () => {
+        const tb = toolbar();
+        const state = {busy: false};
+        expect(set_toolbar_busy(tb.$container, state, true)).toBe(true);
+        expect(tb.save.disabled).toBe(true);
+        expect(tb.cancel.disabled).toBe(true);
+        expect(tb.save.classList.contains("is-loading")).toBe(true);
+        expect(set_toolbar_busy(tb.$container, state, false)).toBe(true);
+        expect(tb.save.disabled).toBe(false);
+        expect(tb.cancel.disabled).toBe(false);
+        expect(tb.undo.disabled).toBe(true);
+        expect(tb.save.classList.contains("is-loading")).toBe(false);
+    });
+
+    it("busy twice then free: Save and Cancel come back (N9)", () => {
+        /*  A record with a picked file went busy for the read and busy
+         *  again for the write; the second pass recorded the buttons the
+         *  first had disabled as disabled on their own, and the free of a
+         *  refused write left Save and Cancel dead.  */
+        const tb = toolbar();
+        const state = {busy: false};
+        set_toolbar_busy(tb.$container, state, true);
+        expect(set_toolbar_busy(tb.$container, state, true)).toBe(false);
+        set_toolbar_busy(tb.$container, state, false);
+        expect(tb.save.disabled).toBe(false);
+        expect(tb.cancel.disabled).toBe(false);
+        expect(tb.undo.disabled).toBe(true);
+        expect(state.busy).toBe(false);
+    });
+
+    it("free while free touches nothing", () => {
+        const tb = toolbar();
+        const state = {busy: false};
+        expect(set_toolbar_busy(tb.$container, state, false)).toBe(false);
+        expect(tb.save.disabled).toBe(false);
+        expect(tb.undo.disabled).toBe(true);
+    });
+
+    it("no container, no state: nothing, and says so", () => {
+        expect(set_toolbar_busy(null, {busy: false}, true)).toBe(false);
+        expect(set_toolbar_busy(toolbar().$container, null, true)).toBe(false);
+    });
+});

package/src/form_writes_in_flight.js

@@ -0,0 +1,60 @@
+/***********************************************************************
+ *          form_writes_in_flight.js
+ *
+ *          The writes of topic forms a C_YUI_TREEDB_TOPICS view has sent
+ *          and not yet answered, by their `form_write` serial. A form that
+ *          waits for its answer (form_waits_for_answer) stays open and
+ *          busy until the host answers, so the host has to answer EVERY
+ *          way a write ends -- and the transport closing under a write in
+ *          flight, or a command that never left because there was no
+ *          session, are two of them that nobody answered: the form stayed
+ *          busy for ever (N8 of the 2026-09-22 review).
+ *
+ *          Copyright (c) 2026, ArtGins.
+ *          All Rights Reserved.
+ ***********************************************************************/
+
+/************************************************************
+ *  A write left: remember whose it is
+ ************************************************************/
+function track_form_write(in_flight, form_write, topic_name)
+{
+    if(!in_flight || !form_write) {
+        return;
+    }
+    in_flight[form_write] = topic_name || "";
+}
+
+/************************************************************
+ *  A write was answered, one way or the other
+ ************************************************************/
+function settle_form_write(in_flight, form_write)
+{
+    if(!in_flight || !form_write) {
+        return;
+    }
+    delete in_flight[form_write];
+}
+
+/************************************************************
+ *  Nothing in flight can be answered any more: take them all,
+ *  as [{form_write, topic_name}], and leave the map empty.
+ ************************************************************/
+function abandon_form_writes(in_flight)
+{
+    const abandoned = [];
+    if(!in_flight) {
+        return abandoned;
+    }
+    Object.keys(in_flight).forEach((serial) => {
+        abandoned.push({form_write: Number(serial), topic_name: in_flight[serial]});
+        delete in_flight[serial];
+    });
+    return abandoned;
+}
+
+export {
+    track_form_write,
+    settle_form_write,
+    abandon_form_writes,
+};

package/src/form_writes_in_flight.test.js

@@ -0,0 +1,45 @@
+import {describe, it, expect} from "vitest";
+import {
+    track_form_write,
+    settle_form_write,
+    abandon_form_writes,
+} from "./form_writes_in_flight.js";
+
+describe("form writes in flight", () => {
+
+    it("a write answered is settled; the others stay", () => {
+        const in_flight = {};
+        track_form_write(in_flight, 1, "users");
+        track_form_write(in_flight, 2, "roles");
+        settle_form_write(in_flight, 1);
+        expect(Object.keys(in_flight)).toEqual(["2"]);
+    });
+
+    it("the transport closes: every write in flight is abandoned, once (N8)", () => {
+        /*  The form of each one is answered EV_WRITE_REFUSED by the host
+         *  and stays open on what was typed; before, it stayed busy for
+         *  ever, because nobody answered a write whose answer was lost.  */
+        const in_flight = {};
+        track_form_write(in_flight, 3, "users");
+        track_form_write(in_flight, 4, "roles");
+        const abandoned = abandon_form_writes(in_flight);
+        expect(abandoned).toEqual([
+            {form_write: 3, topic_name: "users"},
+            {form_write: 4, topic_name: "roles"},
+        ]);
+        expect(abandon_form_writes(in_flight)).toEqual([]);
+    });
+
+    it("a cell edited in place (no serial) is not a form write", () => {
+        const in_flight = {};
+        track_form_write(in_flight, 0, "users");
+        track_form_write(in_flight, undefined, "users");
+        expect(abandon_form_writes(in_flight)).toEqual([]);
+    });
+
+    it("no map: nothing to do", () => {
+        expect(() => track_form_write(null, 1, "x")).not.toThrow();
+        expect(() => settle_form_write(null, 1)).not.toThrow();
+        expect(abandon_form_writes(null)).toEqual([]);
+    });
+});

package/src/host_drafts.js

@@ -0,0 +1,68 @@
+/***********************************************************************
+ *          host_drafts.js
+ *
+ *          The topics a schema editor shows as DRAFTS (edited in
+ *          __system__, not yet saved), told by the host from data. The
+ *          editor marks a topic when a write of this session lands on
+ *          it, and that mark lived in the memory of the session only:
+ *          a reload of the page, a reconnect or a refresh of the model
+ *          lost the chip, the banner and the export warning while
+ *          __system__ still differed from the file in use (N13 of the
+ *          2026-09-22 review). The host reads that difference from
+ *          C_TREEDB's `saved-schema` (`draft_changed`, by treedb) and
+ *          hands it here; the editor applies it to its model.
+ *
+ *          Copyright (c) 2026, ArtGins.
+ *          All Rights Reserved.
+ ***********************************************************************/
+
+/************************************************************
+ *  Mark in `written` the topics of `model` the host names as
+ *  drafts: `drafts` is {treedb_name: [topic names]}. A treedb or a
+ *  topic the model does not hold is ignored. Returns how many were
+ *  marked.
+ ************************************************************/
+function mark_host_drafts(written, model, drafts)
+{
+    let marked = 0;
+    if(!written || !model || !Array.isArray(model.treedbs) || !drafts) {
+        return marked;
+    }
+    for(let treedb of model.treedbs) {
+        const names = drafts[treedb.id];
+        if(!Array.isArray(names) || names.length === 0) {
+            continue;
+        }
+        for(let topic of treedb.topics || []) {
+            if(names.includes(topic.name)) {
+                written[topic.id] = true;
+                marked++;
+            }
+        }
+    }
+    return marked;
+}
+
+/************************************************************
+ *  What a `saved-schema` answer says, as {treedb_name: [topic names]}:
+ *  its `data` is one row per treedb (the unnamed form of the command),
+ *  each carrying `draft_changed` {topic: true}.
+ ************************************************************/
+function drafts_of_saved_answer(rows, into)
+{
+    const drafts = into || {};
+    for(let row of Array.isArray(rows)? rows: []) {
+        const treedb_name = row && row.treedb_name;
+        const changed = row && row.data && row.data.draft_changed;
+        if(!treedb_name || !changed || typeof changed !== "object") {
+            continue;
+        }
+        drafts[treedb_name] = Object.keys(changed).filter((k) => !!changed[k]);
+    }
+    return drafts;
+}
+
+export {
+    mark_host_drafts,
+    drafts_of_saved_answer,
+};

package/src/host_drafts.test.js

@@ -0,0 +1,62 @@
+import {describe, it, expect} from "vitest";
+import {mark_host_drafts, drafts_of_saved_answer} from "./host_drafts.js";
+
+const model = {
+    treedbs: [
+        {id: "treedb_a", name: "treedb_a", topics: [
+            {id: "treedb_a^users", name: "users"},
+            {id: "treedb_a^roles", name: "roles"},
+        ]},
+        {id: "treedb_b", name: "treedb_b", topics: [
+            {id: "treedb_b^users", name: "users"},
+        ]},
+    ],
+};
+
+describe("mark_host_drafts", () => {
+
+    it("marks the topics the host names, by treedb (N13)", () => {
+        /*  The mark lived in the memory of one session: after a reload the
+         *  editor showed no draft while __system__ still differed from the
+         *  file in use. Rebuilt from the host's data.  */
+        const written = {};
+        const n = mark_host_drafts(written, model, {treedb_a: ["users"]});
+        expect(n).toBe(1);
+        expect(written).toEqual({"treedb_a^users": true});
+    });
+
+    it("a topic of the same name in another treedb is another topic", () => {
+        const written = {};
+        mark_host_drafts(written, model, {treedb_b: ["users"]});
+        expect(written).toEqual({"treedb_b^users": true});
+    });
+
+    it("keeps what the session wrote, ignores what the model does not hold", () => {
+        const written = {"treedb_a^roles": true};
+        const n = mark_host_drafts(written, model, {treedb_a: ["nobody"], treedb_z: ["users"]});
+        expect(n).toBe(0);
+        expect(written).toEqual({"treedb_a^roles": true});
+    });
+
+    it("no model, no drafts: nothing", () => {
+        expect(mark_host_drafts({}, null, {treedb_a: ["users"]})).toBe(0);
+        expect(mark_host_drafts({}, model, null)).toBe(0);
+    });
+});
+
+describe("drafts_of_saved_answer", () => {
+
+    it("reads draft_changed of each treedb row", () => {
+        const rows = [
+            {treedb_name: "treedb_a", result: 0, data: {draft_changed: {users: true, roles: false}}},
+            {treedb_name: "treedb_b", result: 0, data: {draft_changed: {}}},
+            {treedb_name: "treedb_c", result: -1, comment: "not open here"},
+        ];
+        expect(drafts_of_saved_answer(rows)).toEqual({treedb_a: ["users"], treedb_b: []});
+    });
+
+    it("a node older than draft_changed says nothing", () => {
+        expect(drafts_of_saved_answer([{treedb_name: "t", data: {can_apply: false}}])).toEqual({});
+        expect(drafts_of_saved_answer(null)).toEqual({});
+    });
+});