@yuneta/gobj-ui 7.23.42 → 7.23.44

package/src/c_yui_schema_editor.js

@@ -519,17 +519,50 @@ function remote_command(gobj, command, kw)
 }
 
 /***************************************************************
- *  The three answers are in: build the schema and remember the
- *  versions it arrived with. The baseline is what "this topic
- *  still needs its version raised" is measured against, so it is
- *  taken here and never touched again until the next load.
+ *  The three answers are in: build the schema.
+ *
+ *  IT DOES NOT TOUCH THE BASELINE, and that is the whole point.
+ *  This runs again on the patch after EVERY write, so a baseline
+ *  taken here was re-taken as the version the write had just
+ *  raised -- and "written, and its version has not moved" then
+ *  read TRUE for a topic whose version had just moved.
+ *
+ *  The banner that says so offers a Raise button, which wrote
+ *  another version, which was measured against itself again: the
+ *  banner came back, every time, and could not be dismissed. One
+ *  operator pressed it thirty-three times on one column delete.
+ *  It is why schema versions climbed by tens with the schema
+ *  unchanged.
+ *
+ *  See start_measuring(): the baseline belongs to the LOAD, the
+ *  same reason `order_undo` was moved out of here before it.
  ***************************************************************/
 function build_model(gobj)
 {
     let priv = gobj.priv;
 
     priv.model = build_schema_model(priv.records);
+}
+
+/***************************************************************
+ *  From here on, "did this session change it?" has an answer.
+ *
+ *  Called ONLY when records arrive from the store: that is what a
+ *  measurement of "changed since" can be measured against. Both
+ *  halves reset together -- a baseline without its `written` is
+ *  the same false positive from the other side, since every
+ *  version equals a baseline just taken.
+ ***************************************************************/
+function start_measuring(gobj)
+{
+    let priv = gobj.priv;
+
     priv.baseline = {};
+    priv.written = {};
+
+    if(!priv.model) {
+        return;
+    }
     for(let treedb of priv.model.treedbs) {
         for(let topic of treedb.topics) {
             priv.baseline[topic.id] = topic.topic_version;
@@ -537,6 +570,24 @@ function build_model(gobj)
     }
 }
 
+/***************************************************************
+ *  "This topic was written and its version did not move."
+ *
+ *  ONE predicate, because it is asked in two places -- the topic
+ *  list draws a chip with it and the column view draws a banner --
+ *  and two copies of a rule is how they drift.
+ ***************************************************************/
+function needs_version_bump(written, baseline, topic)
+{
+    if(!topic || !written || !baseline) {
+        return false;
+    }
+    if(!written[topic.id]) {
+        return false;
+    }
+    return String(baseline[topic.id]) === String(topic.topic_version);
+}
+
 /***************************************************************
  *  Say what the whole store would be refused for.
  *
@@ -987,8 +1038,7 @@ function render_topics(gobj, $body)
     let twice = repeated_names(treedb.topics);
     let $rows = [];
     for(let topic of treedb.topics) {
-        let pending = priv.written[topic.id] &&
-            String(priv.baseline[topic.id]) === String(topic.topic_version);
+        let pending = needs_version_bump(priv.written, priv.baseline, topic);
         /*  Two topics of one name: the id is what tells them apart, and
          *  it is what the url has to carry — addressing by name would
          *  open the first one whichever row was clicked.  */
@@ -1187,10 +1237,7 @@ function version_banner(gobj, topic)
 {
     let priv = gobj.priv;
 
-    if(!priv.written[topic.id]) {
-        return null;
-    }
-    if(String(priv.baseline[topic.id]) !== String(topic.topic_version)) {
+    if(!needs_version_bump(priv.written, priv.baseline, topic)) {
         return null;
     }
     if(is_readonly(gobj)) {
@@ -2558,6 +2605,11 @@ function ac_mt_command_answer(gobj, event, kw, src)
          *  write, which is exactly when the undo has to survive.)  */
         priv.order_undo = {};
         build_model(gobj);
+        /*  Same reason as order_undo above: this is the LOAD, and the
+         *  baseline is what a later "the version did not move" is measured
+         *  against. Taken on the write patches instead, it measured every
+         *  version against itself.  */
+        start_measuring(gobj);
         /*  Back to where the operator was: the load may be a refresh, or
          *  the answer to a deep link that arrived before the model.  */
         return go(gobj, priv.treedb_id, priv.topic_name, priv.diagram, false);
@@ -3424,4 +3476,9 @@ function register_c_yui_schema_editor()
     return create_gclass(GCLASS_NAME);
 }
 
-export {register_c_yui_schema_editor};
+export {
+    register_c_yui_schema_editor,
+    /*  Exported for its test: the rule that decides whether a topic still
+     *  owes a version bump, which is asked in two places.  */
+    needs_version_bump
+};

package/src/json_view_helpers.js

@@ -183,18 +183,34 @@ export function subtree_matches(value, term)
 
 /************************************************************
  *   Fields whose numeric value is an epoch timestamp.
- *   Mirrors the timestampTag list wired into C_YUI_FORM's
- *   jsoneditor control, so the two viewers agree.
+ *
+ *   THE ONE LIST.  C_YUI_FORM's jsoneditor takes its
+ *   `timestampTag` from here: it used to carry its own copy,
+ *   and a copy is how the two stopped agreeing.
+ *
+ *   TWO SPELLINGS, AND LAS DOS SON DEL BACKEND.  timeranger2
+ *   writes `from_t`/`from_tm` in the match_cond of a query and
+ *   `fr_t`/`fr_tm` in the metadata of a topic and of a file --
+ *   which is what a Raw JSON of a treedb actually shows.  With
+ *   only the long pair listed, `to_t` got its date and the
+ *   `fr_t` right above it did not, which reads as a broken
+ *   annotator rather than a missing name.
  ************************************************************/
+const TIME_FIELDS = [
+    "__t__", "__tm__",
+    "t", "tm", "time",
+    "from_t", "to_t", "from_tm", "to_tm",
+    "fr_t", "fr_tm",
+    "t_input", "t_output"
+];
+
 export function is_time_field(field)
 {
-    return field === "__t__" || field === "__tm__" ||
-        field === "tm" || field === "t" || field === "time" ||
-        field === "from_t" || field === "to_t" ||
-        field === "t_input" || field === "t_output" ||
-        field === "from_tm" || field === "to_tm";
+    return TIME_FIELDS.indexOf(field) >= 0;
 }
 
+export {TIME_FIELDS};
+
 /************************************************************
  *   Format an epoch value as a local wall-clock string.
  *   Accepts seconds or milliseconds; returns null when the

package/src/json_view_helpers.test.js

@@ -310,3 +310,36 @@ test("is_pure_collection: the schema this came from", () => {
     /*  A column has content, so it keeps its card. */
     expect(is_pure_collection(col)).toBe(false);
 });
+
+
+/*
+ *  DOS ORTOGRAFIAS, Y LAS DOS SON DEL BACKEND.
+ *
+ *  timeranger2 escribe `from_t`/`from_tm` en el match_cond de una consulta y
+ *  `fr_t`/`fr_tm` en los metadatos de un topic y de un fichero -- que es lo
+ *  que enseña el Raw JSON de un treedb.  Con solo la larga en la lista,
+ *  `to_t` salia fechado y el `fr_t` de encima no: se lee como un anotador
+ *  roto y es un nombre que falta.
+ */
+test("is_time_field reconoce la abreviada, la que sale en un Raw JSON", () => {
+    expect(is_time_field("fr_t")).toBe(true);
+    expect(is_time_field("fr_tm")).toBe(true);
+});
+
+test("is_time_field sigue reconociendo la larga, la de las consultas", () => {
+    expect(is_time_field("from_t")).toBe(true);
+    expect(is_time_field("from_tm")).toBe(true);
+});
+
+test("is_time_field: las dos mitades de cada par, o la fila queda a medias", () => {
+    [["fr_t", "to_t"], ["fr_tm", "to_tm"],
+     ["from_t", "to_t"], ["from_tm", "to_tm"]].forEach((pair) => {
+        expect(is_time_field(pair[0])).toBe(is_time_field(pair[1]));
+    });
+});
+
+test("is_time_field no fecha lo que no es una fecha", () => {
+    ["rows", "id", "", undefined, null].forEach((f) => {
+        expect(is_time_field(f)).toBe(false);
+    });
+});

package/src/schema_version_bump.test.js

@@ -0,0 +1,92 @@
+/***********************************************************************
+ *          schema_version_bump.test.js
+ *
+ *      "This topic was written and its version did not move."
+ *
+ *      THE RULE MEASURES AGAINST A BASELINE, AND THE BASELINE MUST NOT
+ *      MOVE WITH IT.  It used to be re-taken inside build_model(), which
+ *      runs again on the patch after EVERY write -- so it came back as
+ *      the version the write had just raised, the rule read TRUE for a
+ *      topic whose version HAD moved, and the banner that says so
+ *      offered a Raise button that wrote another version and was
+ *      measured against itself again.
+ *
+ *      The banner could not be dismissed.  One operator pressed it
+ *      thirty-three times on a single column delete, and that is why
+ *      schema versions climbed by tens with the schema unchanged.
+ *
+ *          Copyright (c) 2026, ArtGins.
+ *          All Rights Reserved.
+ ***********************************************************************/
+import {describe, it, expect} from "vitest";
+import {needs_version_bump} from "./c_yui_schema_editor.js";
+
+const TOPIC = {id: "device_groups", topic_version: 5};
+
+describe("needs_version_bump", () => {
+    it("says nothing about a topic this session never wrote", () => {
+        expect(needs_version_bump({}, {device_groups: 5}, TOPIC)).toBe(false);
+    });
+
+    it("asks for the bump when the version sits where it was found", () => {
+        expect(needs_version_bump({device_groups: true}, {device_groups: 5}, TOPIC))
+            .toBe(true);
+    });
+
+    it("STOPS asking once the version has moved past the baseline", () => {
+        /*  The case the loop got wrong: the write raised it to 6 and the
+         *  baseline still says 5, so there is nothing left to raise.  */
+        expect(needs_version_bump(
+            {device_groups: true}, {device_groups: 5}, {id: "device_groups", topic_version: 6}
+        )).toBe(false);
+    });
+
+    it("compares as text, so 5 and '5' are the same version", () => {
+        expect(needs_version_bump(
+            {device_groups: true}, {device_groups: "5"}, TOPIC
+        )).toBe(true);
+        expect(needs_version_bump(
+            {device_groups: true}, {device_groups: 5}, {id: "device_groups", topic_version: "5"}
+        )).toBe(true);
+    });
+
+    it("answers false rather than throwing on a missing half", () => {
+        expect(needs_version_bump(null, {device_groups: 5}, TOPIC)).toBe(false);
+        expect(needs_version_bump({device_groups: true}, null, TOPIC)).toBe(false);
+        expect(needs_version_bump({device_groups: true}, {device_groups: 5}, null)).toBe(false);
+    });
+
+    it("a topic with no baseline entry is not owed a bump", () => {
+        expect(needs_version_bump({device_groups: true}, {}, TOPIC)).toBe(false);
+    });
+});
+
+describe("the loop it came from", () => {
+    /*
+     *  What the editor does per bump: raise the version by one. With the
+     *  baseline left alone, ONE press settles it; with the baseline
+     *  re-taken each time -- the old bug -- it never settles.
+     */
+    function press_raise(state) {
+        return {written: state.written, baseline: state.baseline,
+                topic: {id: "t", topic_version: Number(state.topic.topic_version) + 1}};
+    }
+
+    it("settles after a single press", () => {
+        let st = {written: {t: true}, baseline: {t: 5}, topic: {id: "t", topic_version: 5}};
+        expect(needs_version_bump(st.written, st.baseline, st.topic)).toBe(true);
+        st = press_raise(st);
+        expect(needs_version_bump(st.written, st.baseline, st.topic)).toBe(false);
+    });
+
+    it("never settles if the baseline is re-taken with the version", () => {
+        let st = {written: {t: true}, baseline: {t: 5}, topic: {id: "t", topic_version: 5}};
+        let presses = 0;
+        while(needs_version_bump(st.written, st.baseline, st.topic) && presses < 40) {
+            st = press_raise(st);
+            st.baseline = {t: st.topic.topic_version};   /*  the bug  */
+            presses++;
+        }
+        expect(presses).toBe(40);       /*  it ran to the guard: no way out  */
+    });
+});