@yuneta/gobj-ui 7.26.39 → 7.26.41

package/src/c_yui_uplot.js

@@ -30,62 +30,12 @@ import {
 import uPlot from "uplot";
 import "uplot/dist/uPlot.min.css";
 
-import {yui_is_dark, yui_watch_theme} from "./yui_theme.js";
+import {yui_watch_theme} from "./yui_theme.js";
+/*  The ink of the axes -- the X and the Y -- and the palette of the
+ *  series, on both schemes: see yui_uplot_ink.js.  */
+import {yui_uplot_axes, YUI_UPLOT_PALETTE} from "./yui_uplot_ink.js";
 
 
-/***************************************************************
- *  The ink of a chart, and its palette.
- *
- *  uPlot is built for a white page: its axis labels are `#000`
- *  and its grid `rgba(0,0,0,0.07)`, which on the dark scheme are
- *  1.16:1 and 1.04 -- an axis nobody can read and a grid that is
- *  not there. And the series were CSS colour names: `blue` is
- *  2.11:1 on the dark ground, `orange` 1.97 on the light one, so
- *  whichever scheme you were in, one of the lines was a rumour.
- *
- *  These are given to uPlot as FUNCTIONS: it calls them when it
- *  draws, so the value can never be stale -- what goes stale is
- *  the canvas, and that is what EV_THEME redraws.
- *
- *  The palette is six colours that clear 3:1 on BOTH grounds
- *  (worst 3.39 on white, 3.71 on near-black), ordered so the
- *  first two are the pair that survives colour blindness -- blue
- *  and orange, never red and green as the opening pair.
- ***************************************************************/
-function axis_ink()
-{
-    return yui_is_dark()? "#c7cdd8" : "#2e333d";
-}
-
-function grid_ink()
-{
-    return yui_is_dark()? "rgba(199,205,216,0.16)" : "rgba(46,51,61,0.12)";
-}
-
-const CHART_PALETTE = [
-    {stroke: "#2f6fd0", fill: "rgba(47,111,208,0.10)"},     /*  4.88 / 3.71  */
-    {stroke: "#b8620a", fill: "rgba(184,98,10,0.10)"},      /*  4.38 / 4.13  */
-    {stroke: "#2f8f4e", fill: "rgba(47,143,78,0.10)"},      /*  4.07 / 4.45  */
-    {stroke: "#8b5cf6", fill: "rgba(139,92,246,0.10)"},     /*  4.23 / 4.28  */
-    {stroke: "#0e9aa7", fill: "rgba(14,154,167,0.10)"},     /*  3.39 / 5.35  */
-    {stroke: "#d1344b", fill: "rgba(209,52,75,0.10)"},      /*  4.88 / 3.71  */
-];
-
-/*  The axes the host asked for, with the ink it did not ask about.  */
-function themed_axes(axes)
-{
-    let list = Array.isArray(axes)? axes : [axes || {}];
-    return list.map((ax) => {
-        let a = Object.assign({}, ax || {});
-        if(a.stroke === undefined) {
-            a.stroke = axis_ink;
-        }
-        a.grid = Object.assign({stroke: grid_ink}, a.grid || {});
-        a.ticks = Object.assign({stroke: grid_ink}, a.ticks || {});
-        return a;
-    });
-}
-
 /***************************************************************
  *              Constants
  ***************************************************************/
@@ -104,7 +54,7 @@ SDATA(data_type_t.DTP_JSON,     "series",           0,  [{}],   "Data series"),
 SDATA(data_type_t.DTP_JSON,     "axes",             0,  [{}],   "Chart axes"),
 SDATA(data_type_t.DTP_JSON,     "scales",           0,  {},     "Chart scales"),
 SDATA(data_type_t.DTP_JSON,     "data",             0,  [[]],   "Chart data"),
-SDATA(data_type_t.DTP_JSON,     "colors",           0,  CHART_PALETTE,
+SDATA(data_type_t.DTP_JSON,     "colors",           0,  YUI_UPLOT_PALETTE,
     "Series colours, in order. The default palette clears 3:1 on both schemes and opens with the colour-blind-safe pair (blue, orange)"),
 SDATA(data_type_t.DTP_POINTER,  "$container",       0,  null,   "HTML container for the chart"),
 SDATA(data_type_t.DTP_BOOLEAN,  "own_container",    0,  false,  "If true, container is gobj-managed"),
@@ -138,7 +88,7 @@ function mt_create(gobj)
     build_ui(gobj);
 
     /*  A canvas does not restyle itself: the ink is read when uPlot
-     *  DRAWS (see axis_ink), so a theme change only has to reach the
+     *  DRAWS (yui_uplot_ink.js), so a theme change only has to reach the
      *  machine and ask for a redraw. Same wiring as the graphs.  */
     gobj.priv.theme_observer = yui_watch_theme(gobj);
 
@@ -220,7 +170,7 @@ function build_ui(gobj)
         width: gobj_read_attr(gobj, "width"),
         height: gobj_read_attr(gobj, "height"),
         series: gobj_read_attr(gobj, "series"),
-        axes: themed_axes(gobj_read_attr(gobj, "axes")),
+        axes: yui_uplot_axes(gobj_read_attr(gobj, "axes")),
         scales: gobj_read_attr(gobj, "scales"),
     };
     let uplot = new uPlot(
@@ -444,7 +394,7 @@ function ac_add_serie(gobj, event, kw, src)
     }
     let colors = gobj_read_attr(gobj, "colors");
     if(!Array.isArray(colors) || !colors.length) {
-        colors = CHART_PALETTE;
+        colors = YUI_UPLOT_PALETTE;
     }
     /*  `idx` counts uPlot's series, and series[0] is the X AXIS -- so
      *  the first line drawn was taking colours[1] and the palette's

package/src/form_table_edits_ask.wiring.test.js

@@ -0,0 +1,398 @@
+/***********************************************************************
+ *          form_table_edits_ask.wiring.test.js
+ *
+ *      What the reader does to the TABLES of a C_YUI_FORM is `edited`,
+ *      whatever the record the form opened with -- so closing asks.
+ *
+ *      A form opens CHANGED when its record lacks a field the template
+ *      fills with its default. Until 7.26.40 that also unwired the
+ *      tables' `dataChanged` (and only a save, an undo or a load of what
+ *      is stored wired it again), so adding a row, editing a cell,
+ *      deleting a row or editing a nested table marked nothing: since
+ *      7.26.39 the close asks only for `edited`, and it closed without a
+ *      question -- the edit lost. In estadodelaire that is the settings of
+ *      every device without its alarm colours, whose alarms are tables.
+ *
+ *      And the column titles of those tables change language: they were
+ *      drawn at build and never again.
+ *
+ *      Driven through the real gclass on a document double, with a
+ *      Tabulator double that, like Tabulator, draws a row (its formatter
+ *      runs) and says `dataChanged` INSIDE addRow(), synchronously.
+ *
+ *          Copyright (c) 2026, ArtGins.
+ *          All Rights Reserved.
+ ***********************************************************************/
+import {describe, test, expect, beforeAll, beforeEach, vi} from "vitest";
+import {install_dom_double} from "../test/dom_double.js";
+
+install_dom_double();
+
+if(typeof globalThis.ResizeObserver === "undefined") {
+    globalThis.ResizeObserver = class {
+        observe() {}
+        unobserve() {}
+        disconnect() {}
+    };
+}
+
+const tables = vi.hoisted(() => []);
+vi.mock("tabulator-tables", () => {
+    class FakeTabulator {
+        constructor($el, settings) {
+            this.element = $el;
+            this.settings = settings;
+            this.options = {};
+            this.handlers = {};
+            this.initialized = true;
+            this.rows = [];
+            this.installed = {};
+            this.locale = null;
+            this.modules = {
+                localize: {
+                    installLang: (name, strings) => {
+                        this.installed[name] = strings;
+                    }
+                }
+            };
+            tables.push(this);
+            return new Proxy(this, {
+                get(target, prop) {
+                    if(prop in target) {
+                        return target[prop];
+                    }
+                    return () => [];
+                }
+            });
+        }
+        on(ev, fn) {
+            (this.handlers[ev] = this.handlers[ev] || []).push(fn);
+        }
+        off(ev) {
+            delete this.handlers[ev];
+        }
+        emit(ev) {
+            for(const fn of (this.handlers[ev] || [])) {
+                fn([]);
+            }
+        }
+        addRow(record) {
+            /*  The row's element lives in the table's, as in Tabulator:
+             *  a nested table drawn in it is inside the form.  */
+            const $row = document.createElement("div");
+            this.element.appendChild($row);
+            const row = {getElement: () => $row, getData: () => record};
+            if(this.settings && typeof this.settings.rowFormatter === "function") {
+                this.settings.rowFormatter(row);
+            }
+            this.rows.push(row);
+            this.emit("dataChanged");
+            return Promise.resolve(row);
+        }
+        /*  What the trash of a row ends in (row.delete()).  */
+        delete_row() {
+            const row = this.rows.pop();
+            row.getElement().remove();
+            this.emit("dataChanged");
+        }
+        /*  What an edited cell says.  */
+        edit_cell() {
+            this.emit("dataChanged");
+        }
+        validate() {
+            return true;
+        }
+        clearData() {
+            for(const row of this.rows) {
+                row.getElement().remove();
+            }
+            this.rows = [];
+        }
+        setLocale(name) {
+            this.locale = name;
+        }
+        destroy() {
+        }
+    }
+    return {TabulatorFull: FakeTabulator, Tabulator: FakeTabulator};
+});
+
+const {
+    SDATA_END, gclass_create,
+    gobj_start_up, gobj_create_yuno, gobj_create_pure_child,
+    gobj_start, gobj_send_event, gobj_read_attr,
+    set_log_callback,
+} = await import("@yuneta/gobj-js");
+const {register_c_yui_form} = await import("./c_yui_form.js");
+const i18next = (await import("i18next")).default;
+
+const logged = [];
+let yuno = null;
+
+/*  A device's settings, cut down: a defaulted field, and the alarms as
+ *  a table whose rows carry a nested table of triggers.  */
+const TEMPLATE = {
+    template_version: {
+        type: "integer",
+        default: 7,
+        flag: ["hidden", "persistent"]
+    },
+    level: {
+        type: "integer",
+        default: 3,
+        flag: ["writable", "persistent"]
+    },
+    alarms: {
+        type: "array",
+        flag: ["writable", "persistent", "table"],
+        table: {
+            name: {
+                type: "string",
+                header: "alarm name",
+                flag: ["writable", "persistent"]
+            },
+            triggers: {
+                type: "array",
+                flag: ["writable", "persistent", "table"],
+                table: {
+                    measure: {
+                        type: "string",
+                        header: "measure",
+                        flag: ["writable", "persistent"]
+                    }
+                }
+            }
+        }
+    }
+};
+
+/*  `level` missing: the form opens changed.  */
+const LACKING = {
+    template_version: 7,
+    alarms: [{name: "hot", triggers: [{measure: "temperature"}]}]
+};
+
+const COMPLETE = {
+    template_version: 7,
+    level: 3,
+    alarms: [{name: "hot", triggers: [{measure: "temperature"}]}]
+};
+
+beforeAll(async () => {
+    await i18next.init({
+        lng: "en",
+        resources: {
+            en: {translation: {"alarm name": "Alarm name", "measure": "Measure"}},
+            es: {translation: {"alarm name": "Nombre de la alarma", "measure": "Medida"}}
+        }
+    });
+    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_TE_HOST", [], [["ST_IDLE", []]], {}, 0, [SDATA_END()], {}, 0, 0, 0, 0);
+    gclass_create(
+        "C_TEST_TE_APP",
+        [["EV_SAVE_RECORD", 0]],
+        [["ST_IDLE", [
+            ["EV_SAVE_RECORD", () => 0, null],
+        ]]],
+        {}, 0, [SDATA_END()], {}, 0, 0, 0, 0
+    );
+    register_c_yui_form();
+    yuno = gobj_create_yuno("form_table_edits_yuno", "C_TEST_TE_HOST", {});
+    gobj_start(yuno);
+});
+
+beforeEach(async () => {
+    logged.length = 0;
+    await i18next.changeLanguage("en");
+});
+
+let seq = 0;
+
+function build(record)
+{
+    const first = tables.length;
+    const app = gobj_create_pure_child(`teapp${++seq}`, "C_TEST_TE_APP", {}, yuno);
+    gobj_start(app);
+    const form = gobj_create_pure_child(`teform${seq}`, "C_YUI_FORM", {
+        template: TEMPLATE,
+        record: record,
+        editable: true,
+    }, app);
+    gobj_start(form);
+    return {form, first};
+}
+
+/*  The tables the form built since `first`: the alarms table first,
+ *  then a triggers table per alarm row drawn.  */
+function built(first)
+{
+    return tables.slice(first);
+}
+
+/*  The microtasks of addRow().then(): the nested rows load there.  */
+async function settle()
+{
+    await new Promise(resolve => setTimeout(resolve, 0));
+}
+
+function close_asks(form)
+{
+    const kw = {abort_close: false};
+    gobj_send_event(form, "EV_WINDOW_TO_CLOSE", kw, form);
+    return kw.abort_close ? (kw.warning || "(no warning)") : "";
+}
+
+function errors()
+{
+    return logged.filter(l => /error/i.test(l.level) || /ERROR/.test(l.msg));
+}
+
+describe("a form that opens changed hears what the reader does to its tables", () => {
+    test("it opens changed, not edited, and closes without asking", async () => {
+        const {form, first} = build(LACKING);
+        await settle();
+        expect(gobj_read_attr(form, "changes")).toBe(true);
+        expect(gobj_read_attr(form, "edited")).toBe(false);
+        expect(built(first).length).toBe(2);     // the alarms, and the triggers of its row
+        expect(close_asks(form)).toBe("");
+        expect(errors()).toEqual([]);
+    });
+
+    test("an edited cell makes it ask", async () => {
+        const {form, first} = build(LACKING);
+        await settle();
+        built(first)[0].edit_cell();
+        expect(gobj_read_attr(form, "edited")).toBe(true);
+        expect(close_asks(form)).toBe("all changes will be lost");
+        expect(errors()).toEqual([]);
+    });
+
+    test("a deleted row makes it ask", async () => {
+        const {form, first} = build(LACKING);
+        await settle();
+        built(first)[0].delete_row();
+        expect(close_asks(form)).toBe("all changes will be lost");
+    });
+
+    test("a row the reader adds makes it ask; the rows the form loads do not", async () => {
+        const {form, first} = build(LACKING);
+        await settle();
+        const alarms = built(first)[0];
+        expect(alarms.rows.length).toBe(1);     // loaded: no question
+        expect(close_asks(form)).toBe("");
+
+        /*  What the table's add button sends: the reader's row.  */
+        const tables_before = tables.length;
+        gobj_send_event(form, "EV_ADD_TABLE_ROW", {
+            table_id: alarms.element.yui_table_id,
+            record: {},
+            loading: false
+        }, form);
+        expect(alarms.rows.length).toBe(2);
+        expect(tables.length).toBe(tables_before + 1);  // the new row's triggers table
+        expect(gobj_read_attr(form, "edited")).toBe(true);
+        expect(close_asks(form)).toBe("all changes will be lost");
+        expect(errors()).toEqual([]);
+    });
+
+    test("an edit of a NESTED table makes it ask, also one drawn after the load", async () => {
+        const loaded = build(LACKING);
+        await settle();
+        const triggers = built(loaded.first)[1];
+        expect(triggers.rows.length).toBe(1);     // loaded in its row: no question
+        expect(close_asks(loaded.form)).toBe("");
+        triggers.edit_cell();
+        expect(close_asks(loaded.form)).toBe("all changes will be lost");
+
+        /*  An undo draws the rows again, and each row builds its triggers
+         *  table then: a table that did not exist when the form loaded.  */
+        const before_undo = tables.length;
+        gobj_send_event(loaded.form, "EV_UNDO_RECORD", {}, loaded.form);
+        await settle();
+        expect(close_asks(loaded.form)).toBe("");
+        const redrawn = tables.slice(before_undo);
+        expect(redrawn.length).toBe(1);
+        expect(redrawn[0].rows.length).toBe(1);
+        redrawn[0].edit_cell();
+        expect(close_asks(loaded.form)).toBe("all changes will be lost");
+        expect(errors()).toEqual([]);
+    });
+
+    test("a record loaded LATER that lacks a field (a reload, a refused save) still hears them", async () => {
+        const {form, first} = build(COMPLETE);
+        await settle();
+        expect(gobj_read_attr(form, "changes")).toBe(false);
+        gobj_send_event(form, "EV_LOAD_RECORD", LACKING, form);
+        await settle();
+        expect(gobj_read_attr(form, "changes")).toBe(true);
+        expect(gobj_read_attr(form, "edited")).toBe(false);
+        expect(close_asks(form)).toBe("");
+        built(first)[0].edit_cell();
+        expect(close_asks(form)).toBe("all changes will be lost");
+        expect(errors()).toEqual([]);
+    });
+
+    test("a table built after the load (tableBuilt) takes its rows without a question", async () => {
+        const {form, first} = build(COMPLETE);
+        await settle();
+        const alarms = built(first)[0];
+        /*  A table not built yet: no rows, and the ones it is given wait
+         *  for its `tableBuilt`.  */
+        alarms.clearData();
+        alarms.initialized = false;
+        gobj_send_event(form, "EV_LOAD_RECORD", LACKING, form);
+        await settle();
+        expect(alarms.rows.length).toBe(0);
+        /*  Tabulator builds the table now, long after the load returned.  */
+        alarms.initialized = true;
+        alarms.emit("tableBuilt");
+        await settle();
+        expect(alarms.rows.length).toBe(1);
+        expect(gobj_read_attr(form, "edited")).toBe(false);
+        expect(close_asks(form)).toBe("");
+        expect(errors()).toEqual([]);
+    });
+
+    test("with a complete record it asks as before", async () => {
+        /*  The waits are the 200 ms after which 7.26.40 wired the tables
+         *  again: with them this case passes on the code before too.  */
+        const wait = () => new Promise(resolve => setTimeout(resolve, 260));
+        const {form, first} = build(COMPLETE);
+        await wait();
+        expect(gobj_read_attr(form, "changes")).toBe(false);
+        built(first)[1].edit_cell();
+        expect(close_asks(form)).toBe("all changes will be lost");
+        gobj_send_event(form, "EV_SAVE_RECORD", {}, form);
+        expect(close_asks(form)).toBe("");
+        await wait();
+        built(first)[0].edit_cell();
+        expect(close_asks(form)).toBe("all changes will be lost");
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("the column titles of the tables change language", () => {
+    test("each table, nested ones too, is given its titles in the new language", async () => {
+        const {form, first} = build(COMPLETE);
+        await settle();
+        const [alarms, triggers] = built(first);
+
+        await i18next.changeLanguage("es");
+        gobj_send_event(form, "EV_LANGUAGE_CHANGED", {}, form);
+
+        expect(alarms.locale).toBeTruthy();
+        expect(alarms.installed[alarms.locale].columns).toEqual({
+            name: "Nombre de la alarma",
+            triggers: "triggers"
+        });
+        expect(triggers.installed[triggers.locale].columns).toEqual({measure: "Medida"});
+        /*  No column was rebuilt to get there: the rows (and the nested
+         *  table) are the ones loaded.  */
+        expect(alarms.rows.length).toBe(1);
+        expect(triggers.rows.length).toBe(1);
+        expect(errors()).toEqual([]);
+    });
+});

package/src/form_table_rearm.wiring.test.js

@@ -5,11 +5,13 @@
  *      a save or an undo -- which is what a dialog does: it closes the
  *      moment the record is saved.
  *
- *      set_changed_stated(false) re-wires the tables' `dataChanged` from
- *      a 200 ms timer. Since 7.26.7 destroy_ui() destroys the widgets and
- *      nulls `$table.tabulator`, and the timer, left running, called
- *      `.on()` on that null: an uncaught TypeError. The timer is kept and
- *      cancelled now, and it skips a table that is gone.
+ *      set_changed_stated(false) used to re-wire the tables' `dataChanged`
+ *      from a 200 ms timer. Since 7.26.7 destroy_ui() destroys the widgets
+ *      and nulls `$table.tabulator`, and the timer, left running, called
+ *      `.on()` on that null: an uncaught TypeError. Since 7.26.41 there is
+ *      no timer: each table is wired once, when it is built, and stays
+ *      wired (form_table_edits_ask.wiring.test.js says why). These cases
+ *      keep guarding the destroy right after a save or an undo.
  *
  *          Copyright (c) 2026, ArtGins.
  *          All Rights Reserved.
@@ -117,7 +119,7 @@ function build(rows)
 }
 
 describe("a form with a table, destroyed right after", () => {
-    test("an undo: the deferred re-wiring does not throw", async () => {
+    test("an undo, then the destroy: nothing left behind throws", async () => {
         const {form} = build();
         expect(tables.length).toBeGreaterThan(0);
         const errors = [];
@@ -135,7 +137,7 @@ describe("a form with a table, destroyed right after", () => {
         expect(errors).toEqual([]);
     });
 
-    test("a live form is still re-wired", async () => {
+    test("a live form's table stays wired, once", async () => {
         const {form} = build();
         const table = tables[tables.length - 1];
         gobj_send_event(form, "EV_UNDO_RECORD", {}, form);

package/src/uplot_ink.test.js

@@ -0,0 +1,105 @@
+/***********************************************************************
+ *          uplot_ink.test.js
+ *
+ *      The axes of a chart carry the ink of the theme -- the Y axis
+ *      too. uPlot always draws one (its setDefaults() makes axes[1]
+ *      whether it was given or not, with its own black), and
+ *      C_YUI_UPLOT inked only the axes it was handed: by default one,
+ *      the X. In the dark scheme the values of every Y axis of the
+ *      library were black on near-black (a user's report, the cards of
+ *      estadodelaire).
+ *
+ *          Copyright (c) 2026, ArtGins.
+ *          All Rights Reserved.
+ ***********************************************************************/
+import {describe, test, expect, beforeAll, beforeEach, afterEach, vi} from "vitest";
+import {install_dom_double} from "../test/dom_double.js";
+
+install_dom_double();
+
+/*  What C_YUI_UPLOT hands to uPlot, kept by the stand-in.  */
+let given = null;
+vi.mock("uplot", () => ({
+    default: class {
+        constructor(opts) {
+            given = opts;
+            this.series = [{}];
+        }
+        setSize() {}
+        addSeries() {}
+        redraw() {}
+        destroy() {}
+    }
+}));
+
+const {
+    gobj_start_up, gobj_create_yuno, gobj_create_pure_child, gclass_create,
+    set_log_callback, SDATA_END,
+} = await import("@yuneta/gobj-js");
+const {register_c_yui_uplot} = await import("./c_yui_uplot.js");
+const {
+    yui_uplot_axes, yui_uplot_axis_ink, yui_uplot_grid_ink,
+} = await import("./yui_uplot_ink.js");
+
+const logged = [];
+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_INK_HOST", [], [["ST_IDLE", []]], {}, 0, [SDATA_END()], {}, 0, 0, 0, 0);
+    register_c_yui_uplot();
+    yuno = gobj_create_yuno("ink_yuno", "C_TEST_INK_HOST", {});
+});
+
+beforeEach(() => {
+    logged.length = 0;
+    given = null;
+});
+
+afterEach(() => {
+    document.documentElement.removeAttribute("data-theme");
+});
+
+describe("yui_uplot_axes()", () => {
+    test("gives the X and the Y axes, the two uPlot draws", () => {
+        expect(yui_uplot_axes([{}]).length).toBe(2);
+        expect(yui_uplot_axes(undefined).length).toBe(2);
+        expect(yui_uplot_axes([]).length).toBe(2);
+        expect(yui_uplot_axes([{}, {}, {scale: "%"}]).length).toBe(3);
+    });
+
+    test("inks each one with the theme, read when uPlot draws", () => {
+        const axes = yui_uplot_axes([{}]);
+        for(const a of axes) {
+            expect(a.stroke).toBe(yui_uplot_axis_ink);
+            expect(a.grid.stroke).toBe(yui_uplot_grid_ink);
+            expect(a.ticks.stroke).toBe(yui_uplot_grid_ink);
+        }
+        document.documentElement.setAttribute("data-theme", "light");
+        expect(axes[1].stroke()).toBe("#2e333d");
+        document.documentElement.setAttribute("data-theme", "dark");
+        expect(axes[1].stroke()).toBe("#c7cdd8");
+    });
+
+    test("keeps what the host gave, and does not touch its objects", () => {
+        const mine = [{stroke: "red", grid: {show: false}}];
+        const axes = yui_uplot_axes(mine);
+        expect(axes[0].stroke).toBe("red");
+        expect(axes[0].grid).toEqual({stroke: yui_uplot_grid_ink, show: false});
+        expect(mine).toEqual([{stroke: "red", grid: {show: false}}]);
+    });
+});
+
+describe("C_YUI_UPLOT", () => {
+    test("hands uPlot a Y axis with the ink of the theme", () => {
+        gobj_create_pure_child("ink_chart", "C_YUI_UPLOT", {}, yuno);
+        expect(given).toBeTruthy();
+        expect(given.axes.length).toBe(2);
+        expect(given.axes[1].stroke).toBe(yui_uplot_axis_ink);
+        expect(given.axes[1].grid.stroke).toBe(yui_uplot_grid_ink);
+        expect(logged.filter((l) => /error/i.test(l.level))).toEqual([]);
+    });
+});

package/src/yui_tabulator_i18n.js

@@ -14,6 +14,12 @@
  *          new Tabulator($el, {..., ...yui_tabulator_lang(t)});
  *          yui_tabulator_relocalize(table, t);   // on a language change
  *
+ *      A view whose COLUMN TITLES change language hands them too, in the
+ *      new language, by field -- Tabulator binds each column's title to its
+ *      locale, so they change with it and no column is rebuilt:
+ *
+ *          yui_tabulator_relocalize(table, t, {device_id: t("device id")});
+ *
  *      Every key carries an English `defaultValue`, so an app that does not
  *      define it renders exactly what Tabulator rendered before — the
  *      keys are an OPPORTUNITY to translate, never a requirement.
@@ -236,7 +242,18 @@ function yui_tabulator_name_editor(column_def, name_of)
     };
 }
 
-function yui_tabulator_relocalize(table, t)
+/***************************************************************
+ *  yui_tabulator_relocalize() -- see "Put an EXISTING table in the
+ *  current language" above.
+ *
+ *  `titles`, optional: {field: title}, the titles of the columns in
+ *  the new language, already translated. They go in the locale
+ *  (`columns`), where Tabulator binds each column's title: setLocale()
+ *  draws them again without rebuilding a column -- updateDefinition()
+ *  re-renders every row, and a row whose formatter builds something (a
+ *  nested table) builds it anew. A field left out keeps its title.
+ ***************************************************************/
+function yui_tabulator_relocalize(table, t, titles)
 {
     if(!table) {
         return;
@@ -244,6 +261,9 @@ function yui_tabulator_relocalize(table, t)
     try {
         let name = next_lang_name();
         let strings = tabulator_strings(t);
+        if(titles && typeof titles === "object") {
+            strings.columns = Object.assign({}, titles);
+        }
 
         /*  Tabulator DEEP-CLONES options.langs into its localize module when
          *  the table is built, and never looks at the option again: writing a