@yuneta/gobj-ui 7.25.4 → 7.25.6

package/src/form_time_value.js

@@ -6,6 +6,29 @@
  *          them, and they must be each other's inverse: a writable time
  *          column travels back on EVERY save of the record.
  *
+ *          KNOWN LIMIT -- the change of hour. A `datetime-local` holds a
+ *          LOCAL WALL time and no offset, and a wall time is not always
+ *          one instant:
+ *
+ *            - the night the clocks go back (autumn), one hour happens
+ *              twice. "02:30" names two instants an hour apart, and
+ *              `new Date("YYYY-MM-DDT02:30:00")` answers the EARLIER one
+ *              (ECMAScript's "compatible" disambiguation). An epoch in the
+ *              SECOND pass of that hour is shown as 02:30 and comes back
+ *              one hour earlier: saving the record -- any field of it --
+ *              moves a writable time column that holds it by -3600 s.
+ *            - the night the clocks go forward (spring), one hour does not
+ *              exist. No epoch is shown in it, so nothing read comes back
+ *              wrong; a wall time TYPED in it is moved forward by the
+ *              browser.
+ *
+ *          Not fixable here without the offset, which the input cannot
+ *          carry. What is safe: a read-only time column never goes back
+ *          (treedb_write_plan.js, col_goes_back_to_treedb), and a time
+ *          pkey2 goes back as the record had it, never through this
+ *          widget (instance_keys_of). A writable time column edited or
+ *          merely saved inside the repeated hour is the exposed case.
+ *
  *          Copyright (c) 2026, ArtGins.
  *          All Rights Reserved.
  ****************************************************************************/

package/src/form_writes_in_flight.js

@@ -2,18 +2,33 @@
  *          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).
+ *          and not yet answered. 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).
+ *
+ *          A write is known by its TOPIC and its `form_write` serial,
+ *          never by the serial alone: each topic has its own form, and
+ *          each form counts its serials from 1. Keyed by the serial, two
+ *          forms with a write in flight at once shared the key "1", the
+ *          first answer settled both, and the transport closing then
+ *          answered only one of them.
  *
  *          Copyright (c) 2026, ArtGins.
  *          All Rights Reserved.
  ***********************************************************************/
 
+/************************************************************
+ *  The key of one write: `<topic>^<serial>`.
+ ************************************************************/
+function form_write_key(topic_name, form_write)
+{
+    return `${topic_name || ""}^${form_write}`;
+}
+
 /************************************************************
  *  A write left: remember whose it is
  ************************************************************/
@@ -22,18 +37,21 @@ function track_form_write(in_flight, form_write, topic_name)
     if(!in_flight || !form_write) {
         return;
     }
-    in_flight[form_write] = topic_name || "";
+    in_flight[form_write_key(topic_name, form_write)] = {
+        form_write: form_write,
+        topic_name: topic_name || ""
+    };
 }
 
 /************************************************************
  *  A write was answered, one way or the other
  ************************************************************/
-function settle_form_write(in_flight, form_write)
+function settle_form_write(in_flight, form_write, topic_name)
 {
     if(!in_flight || !form_write) {
         return;
     }
-    delete in_flight[form_write];
+    delete in_flight[form_write_key(topic_name, form_write)];
 }
 
 /************************************************************
@@ -46,9 +64,10 @@ function abandon_form_writes(in_flight)
     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];
+    Object.keys(in_flight).forEach((key) => {
+        const w = in_flight[key];
+        abandoned.push({form_write: Number(w.form_write), topic_name: w.topic_name});
+        delete in_flight[key];
     });
     return abandoned;
 }

package/src/form_writes_in_flight.test.js

@@ -11,8 +11,23 @@ describe("form writes in flight", () => {
         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"]);
+        settle_form_write(in_flight, 1, "users");
+        expect(abandon_form_writes(in_flight)).toEqual([
+            {form_write: 2, topic_name: "roles"},
+        ]);
+    });
+
+    it("two forms, each at its serial 1: two writes, not one", () => {
+        /*  Each topic's form counts its serials from 1. Keyed by the serial
+         *  alone, the answer of one form settled the other's write, and a
+         *  transport closing then left that one busy for ever.  */
+        const in_flight = {};
+        track_form_write(in_flight, 1, "users");
+        track_form_write(in_flight, 1, "roles");
+        settle_form_write(in_flight, 1, "users");
+        expect(abandon_form_writes(in_flight)).toEqual([
+            {form_write: 1, topic_name: "roles"},
+        ]);
     });
 
     it("the transport closes: every write in flight is abandoned, once (N8)", () => {
@@ -39,7 +54,7 @@ describe("form writes in flight", () => {
 
     it("no map: nothing to do", () => {
         expect(() => track_form_write(null, 1, "x")).not.toThrow();
-        expect(() => settle_form_write(null, 1)).not.toThrow();
+        expect(() => settle_form_write(null, 1, "x")).not.toThrow();
         expect(abandon_form_writes(null)).toEqual([]);
     });
 });

package/src/host_drafts.js

@@ -10,17 +10,42 @@
  *          __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.
+ *          hands it here; the editor applies it to its model, in place
+ *          of what the host said before.
+ *
+ *          What `draft_changed` measures depends on the node: the draft
+ *          against the SAVED schema on a node newer than yunetas 7.25.3,
+ *          and against the file IN USE on a 7.25.3 node -- where a topic saved and
+ *          not yet applied is still named, and the editor, which cannot
+ *          tell the two apart, shows it as a draft until the Apply.
  *
  *          Copyright (c) 2026, ArtGins.
  *          All Rights Reserved.
  ***********************************************************************/
 
+/************************************************************
+ *  The topics of `model` the host names as drafts, as
+ *  {topic id: true}: `drafts` is {treedb_name: [topic names]}. A
+ *  treedb or a topic the model does not hold is ignored.
+ *
+ *  What the editor keeps is THIS, apart from what its own session
+ *  wrote, and replaced whole on every EV_DRAFTS: the host is the
+ *  truth after a reload. Folded into the session's marks, a topic the
+ *  host once named stayed a draft after the save that published it.
+ ************************************************************/
+function host_draft_ids(model, drafts)
+{
+    const ids = {};
+    mark_host_drafts(ids, model, drafts);
+    return ids;
+}
+
 /************************************************************
  *  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.
+ *  marked. It only ADDS: a caller that must forget what the host
+ *  no longer names starts from an empty map (host_draft_ids()).
  ************************************************************/
 function mark_host_drafts(written, model, drafts)
 {
@@ -63,6 +88,7 @@ function drafts_of_saved_answer(rows, into)
 }
 
 export {
+    host_draft_ids,
     mark_host_drafts,
     drafts_of_saved_answer,
 };

package/src/host_drafts.test.js

@@ -1,5 +1,5 @@
 import {describe, it, expect} from "vitest";
-import {mark_host_drafts, drafts_of_saved_answer} from "./host_drafts.js";
+import {host_draft_ids, mark_host_drafts, drafts_of_saved_answer} from "./host_drafts.js";
 
 const model = {
     treedbs: [
@@ -60,3 +60,26 @@ describe("drafts_of_saved_answer", () => {
         expect(drafts_of_saved_answer(null)).toEqual({});
     });
 });
+
+describe("host_draft_ids", () => {
+
+    it("resolves the host's names on the model, as topic ids", () => {
+        expect(host_draft_ids(model, {treedb_a: ["users"], treedb_b: ["users"]}))
+            .toEqual({"treedb_a^users": true, "treedb_b^users": true});
+    });
+
+    it("is a fresh map every time: what the host stopped naming is gone (M1)", () => {
+        /*  mark_host_drafts() only ADDS, and the editor fed it the same map
+         *  every time: a topic the host named before the Save stayed a
+         *  draft after it.  */
+        const before = host_draft_ids(model, {treedb_a: ["users", "roles"]});
+        const after = host_draft_ids(model, {treedb_a: []});
+        expect(before).toEqual({"treedb_a^users": true, "treedb_a^roles": true});
+        expect(after).toEqual({});
+    });
+
+    it("no model, no drafts: empty", () => {
+        expect(host_draft_ids(null, {treedb_a: ["users"]})).toEqual({});
+        expect(host_draft_ids(model, null)).toEqual({});
+    });
+});

package/src/schema_editor_drafts.wiring.test.js

@@ -0,0 +1,176 @@
+/***********************************************************************
+ *          schema_editor_drafts.wiring.test.js
+ *
+ *      EV_DRAFTS driven through a real C_YUI_SCHEMA_EDITOR on a document
+ *      double. The helper was right and tested; the ACTION folded the
+ *      host's marks into the session's, so a topic the host named before
+ *      a Save stayed a draft after it (M1 of the 2026-09-23 review).
+ *
+ *          Copyright (c) 2026, ArtGins.
+ *          All Rights Reserved.
+ ***********************************************************************/
+import {describe, test, expect, beforeAll, beforeEach} from "vitest";
+import {install_dom_double} from "../test/dom_double.js";
+
+install_dom_double();
+
+const {
+    SDATA_END,
+    gclass_create,
+    gobj_start_up, gobj_create_yuno, gobj_create, gobj_create_service,
+    gobj_start, gobj_send_event, gobj_read_attr,
+    gobj_change_state,
+    set_log_callback,
+} = await import("@yuneta/gobj-js");
+const {register_c_yui_schema_editor, topic_is_draft} = await import("./c_yui_schema_editor.js");
+
+const logged = [];
+const commands = [];
+
+/*  The yuno's system schema: one treedb, two topics.  */
+const RECORDS = {
+    treedbs: [{id: "db", schema_version: 4}],
+    topics: [
+        {id: "db.users", value: "users", order: 1, pkey: "id", topic_version: 2,
+         treedbs: ["treedbs^db^topics"]},
+        {id: "db.roles", value: "roles", order: 2, pkey: "id", topic_version: 1,
+         treedbs: ["treedbs^db^topics"]},
+    ],
+    cols: [
+        {id: "db.users.id", value: "id", order: 1, type: "string",
+         flag: ["persistent", "required"], topics: ["topics^db.users^cols"]},
+        {id: "db.roles.id", value: "id", order: 1, type: "string",
+         flag: ["persistent", "required"], topics: ["topics^db.roles^cols"]},
+    ],
+};
+
+function remote_command_parser(gobj, command, kw, src)
+{
+    commands.push({command, kw, src});
+    return null;
+}
+
+let yuno = null;
+
+beforeAll(() => {
+    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_HOST", [], [["ST_IDLE", []]], {}, 0, [SDATA_END()], {}, 0, 0, 0, 0);
+    gclass_create(
+        "C_TEST_EDITOR_HOST",
+        [["EV_POSITION_CHANGED", 0], ["EV_RECORD_WRITTEN", 0], ["EV_SCHEMA_CHECKED", 0]],
+        [["ST_IDLE", [
+            ["EV_POSITION_CHANGED", () => 0, null],
+            ["EV_RECORD_WRITTEN",   () => 0, null],
+            ["EV_SCHEMA_CHECKED",   () => 0, null]
+        ]]],
+        {}, 0, [SDATA_END()], {}, 0, 0, 0, 0
+    );
+    gclass_create(
+        "C_TEST_REMOTE",
+        [],
+        [["ST_SESSION", []]],
+        {mt_command_parser: remote_command_parser},
+        0, [SDATA_END()], {}, 0, 0, 0, 0
+    );
+    register_c_yui_schema_editor();
+    yuno = gobj_create_yuno("drafts_yuno", "C_TEST_HOST", {});
+    gobj_start(yuno);
+});
+
+beforeEach(() => {
+    logged.length = 0;
+    commands.length = 0;
+});
+
+/*  Answer every `nodes` the editor asked, the way a transport does: the
+ *  request's frame on top of the command_stack.  */
+function answer_the_load(editor, remote)
+{
+    const asked = commands.filter((c) => c.command === "nodes");
+    commands.length = 0;
+    for(const c of asked) {
+        gobj_send_event(editor, "EV_MT_COMMAND_ANSWER", {
+            result: 0,
+            data: RECORDS[c.kw.topic_name],
+            __md_iev__: {command_stack: [{command: "nodes", kw: c.kw}]}
+        }, remote);
+    }
+    return asked.length;
+}
+
+function build(name)
+{
+    const remote = gobj_create_service(`${name}_remote`, "C_TEST_REMOTE", {}, yuno);
+    gobj_change_state(remote, "ST_SESSION");
+    const host = gobj_create(`${name}_host`, "C_TEST_EDITOR_HOST", {}, yuno);
+    const editor = gobj_create(`${name}_editor`, "C_YUI_SCHEMA_EDITOR", {
+        gobj_remote_yuno: remote,
+        treedb_name: "treedb_system_schema",
+        base_route: "/schemas"
+    }, host);
+    gobj_start(editor);
+    expect(answer_the_load(editor, remote)).toBe(3);
+    gobj_send_event(editor, "EV_SHOW", {subpath: "db"}, host);
+    return {editor, remote, host};
+}
+
+function drafts_on_screen(editor)
+{
+    const $c = gobj_read_attr(editor, "$container");
+    return $c.querySelectorAll(".SCHEMA_TOPIC_VERSION .is-warning").length;
+}
+
+function is_draft(editor, topic_id)
+{
+    return topic_is_draft(editor.priv, {id: topic_id});
+}
+
+describe("EV_DRAFTS: the host is the truth", () => {
+
+    test("the host names a topic: it is a draft, on screen too", () => {
+        const {editor, host} = build("d1");
+        gobj_send_event(editor, "EV_DRAFTS", {drafts: {db: ["users"]}}, host);
+        expect(is_draft(editor, "db.users")).toBe(true);
+        expect(is_draft(editor, "db.roles")).toBe(false);
+        expect(drafts_on_screen(editor)).toBe(1);
+    });
+
+    test("the host names none any more (a Save): the mark goes (M1)", () => {
+        /*  It only ever ADDED: after the Save the editor still said
+         *  "unsaved schema changes".  */
+        const {editor, host} = build("d2");
+        gobj_send_event(editor, "EV_DRAFTS", {drafts: {db: ["users", "roles"]}}, host);
+        expect(drafts_on_screen(editor)).toBe(2);
+
+        gobj_send_event(editor, "EV_DRAFTS", {drafts: {db: []}}, host);
+        expect(is_draft(editor, "db.users")).toBe(false);
+        expect(is_draft(editor, "db.roles")).toBe(false);
+        expect(drafts_on_screen(editor)).toBe(0);
+    });
+
+    test("a reload keeps what the host said last, and only that", () => {
+        const {editor, remote, host} = build("d3");
+        gobj_send_event(editor, "EV_DRAFTS", {drafts: {db: ["roles"]}}, host);
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(is_draft(editor, "db.roles")).toBe(true);
+        expect(is_draft(editor, "db.users")).toBe(false);
+    });
+
+    test("what this session wrote is not cleared by the host's answer", () => {
+        const {editor, host} = build("d4");
+        editor.priv.written["db.users"] = true;     /*  a write of this session  */
+        gobj_send_event(editor, "EV_DRAFTS", {drafts: {}}, host);
+        expect(is_draft(editor, "db.users")).toBe(true);
+    });
+
+    test("no error logged on the way", () => {
+        const {editor, host} = build("d5");
+        gobj_send_event(editor, "EV_DRAFTS", {drafts: {db: ["users"]}}, host);
+        gobj_send_event(editor, "EV_DRAFTS", {drafts: {}}, host);
+        expect(logged.filter((l) => l.level === "error").map((l) => l.msg)).toEqual([]);
+    });
+});