@yuneta/gobj-ui 7.8.0 → 7.8.1

package/README.md

@@ -491,6 +491,39 @@ The buttons of that toolbar never shrink. When the row runs out of room, the
 url is what gives way, cut with an ellipsis, and the whole value stays in the
 `title` and the `aria-label`.
 
+### Editing a topic table in place
+
+A writable scalar is editable in the table, in edition mode
+(`with_inline_edit`, default on). Changing one field used to mean opening the
+record form, changing it, saving and closing.
+
+**Which cells, and why not the rest.** The schema decides first: only a column
+flagged `writable`, and never the pkey — renaming what a record is KEYED by is
+not a field edit. Then the type: a hook holds children and an fkey IS a link,
+so both are edited by linking; a dict or a list is a document the form has an
+editor for; a date cell shows a formatted string over an epoch, so typing into
+it would write the string. Those stay with the form, one click away on the
+same row. `boolean` gets a tick, `enum` the list of its own values, numbers a
+number editor.
+
+**The write is a partial update with no `autolink`, and that is the whole
+safety of it.** `treedb_update_node()` merges (`json_object_update`), so the
+fields it does not carry are left alone; `autolink` is the option that wipes a
+node's links and rebuilds them from the fkeys the record carries, and on a
+partial record it reads that as "no parents", detaches the node and answers
+**success**. So a cell edit travels as its own event, `EV_UPDATE_FIELD`, and
+not as `EV_UPDATE_RECORD` — that one does send autolink, and may, because the
+form hands it the whole record with its fkeys in it. See
+`schema_write_options.js` for the rule and why each word of it is there.
+
+`editable` is a **function** on the column, not a flag: edition mode is
+toggled on a table that is already built, so the answer has to be asked for at
+the moment of the click.
+
+A refused write puts the topic back to what the treedb has. Leaving the typed
+value on screen is tolerable for a form, which stays open on the values it
+failed with; a cell edited in place would just look saved.
+
 ### Reading a topic table: filters, columns, CSV
 
 `C_YUI_TREEDB_TOPIC_WITH_FORM` had one global search box over the loaded rows.

package/dist/gobj-ui.cjs.js

@@ -14416,6 +14416,66 @@ function yui_shell_show_route_map(shell, opts) {
 	return modal_ref.modal;
 }
 //#endregion
+//#region src/nodes_answer.js
+/***********************************************************************
+*          nodes_answer.js
+*
+*      What the `nodes` command answered, whatever shape it came in.
+*
+*      A treedb lives in memory on the backend, so walking it is not
+*      what costs: serializing every node, pushing it through a
+*      websocket and parsing it here is. So `nodes` learned to answer a
+*      PAGE, with the contract `list-keys` of C_TRANGER already used:
+*
+*          no `limit`  ->  the plain list it has always answered
+*          a `limit`   ->  {total_rows, pages, data}
+*
+*      Both shapes are alive at once and will be for a long time: the
+*      SPA talks to backends the operator configures, and an older one
+*      answers the plain list whatever this app asks for. So the shape
+*      is read, never assumed — a view that indexed `data` as an array
+*      would render an object's keys as rows the day a backend
+*      upgraded, which is the kind of break that looks like a bug in
+*      the app.
+*
+*      Pure and tested, because this is exactly the sort of thing that
+*      cannot be exercised until the other side moves.
+*
+*          Copyright (c) 2026, ArtGins.
+*          All Rights Reserved.
+***********************************************************************/
+/***************************************************************
+*  nodes_answer(data) -> {rows, total, pages, paged}
+*
+*  `rows` is always an array, so a caller never has to ask which
+*  shape it got. `paged` says whether the backend answered a page,
+*  which is the one thing a caller may legitimately care about (it is
+*  what tells a pager it has something to page).
+***************************************************************/
+function nodes_answer(data) {
+	if (Array.isArray(data)) return {
+		rows: data,
+		total: data.length,
+		pages: 1,
+		paged: false
+	};
+	if (data && typeof data === "object" && Array.isArray(data.data)) {
+		let rows = data.data;
+		return {
+			rows,
+			total: typeof data.total_rows === "number" ? data.total_rows : rows.length,
+			pages: typeof data.pages === "number" && data.pages > 0 ? data.pages : 1,
+			paged: true
+		};
+	}
+	return {
+		rows: [],
+		total: 0,
+		pages: 1,
+		paged: false
+	};
+}
+//#endregion
 //#region src/c_yui_treedb_topics.js
 /***********************************************************************
 *          c_yui_treedb_topics.js
@@ -15629,7 +15689,7 @@ function ac_mt_command_answer$2(gobj, event, kw, src) {
 			let topic_name = (0, _yuneta_gobj_js.kw_get_str)(gobj, kw_command, "topic_name", "", _yuneta_gobj_js.kw_flag_t.KW_REQUIRED);
 			if (result >= 0) {
 				let gobj_topic_form = (0, _yuneta_gobj_js.gobj_find_child)(gobj, { __gobj_name__: `${(0, _yuneta_gobj_js.gobj_name)(gobj)}?${topic_name}` });
-				(0, _yuneta_gobj_js.gobj_send_event)(gobj_topic_form, "EV_LOAD_NODES", data, gobj);
+				(0, _yuneta_gobj_js.gobj_send_event)(gobj_topic_form, "EV_LOAD_NODES", nodes_answer(data).rows, gobj);
 			}
 			break;
 		case "create-node":

package/dist/gobj-ui.es.js

@@ -14411,6 +14411,66 @@ function yui_shell_show_route_map(shell, opts) {
 	return modal_ref.modal;
 }
 //#endregion
+//#region src/nodes_answer.js
+/***********************************************************************
+*          nodes_answer.js
+*
+*      What the `nodes` command answered, whatever shape it came in.
+*
+*      A treedb lives in memory on the backend, so walking it is not
+*      what costs: serializing every node, pushing it through a
+*      websocket and parsing it here is. So `nodes` learned to answer a
+*      PAGE, with the contract `list-keys` of C_TRANGER already used:
+*
+*          no `limit`  ->  the plain list it has always answered
+*          a `limit`   ->  {total_rows, pages, data}
+*
+*      Both shapes are alive at once and will be for a long time: the
+*      SPA talks to backends the operator configures, and an older one
+*      answers the plain list whatever this app asks for. So the shape
+*      is read, never assumed — a view that indexed `data` as an array
+*      would render an object's keys as rows the day a backend
+*      upgraded, which is the kind of break that looks like a bug in
+*      the app.
+*
+*      Pure and tested, because this is exactly the sort of thing that
+*      cannot be exercised until the other side moves.
+*
+*          Copyright (c) 2026, ArtGins.
+*          All Rights Reserved.
+***********************************************************************/
+/***************************************************************
+*  nodes_answer(data) -> {rows, total, pages, paged}
+*
+*  `rows` is always an array, so a caller never has to ask which
+*  shape it got. `paged` says whether the backend answered a page,
+*  which is the one thing a caller may legitimately care about (it is
+*  what tells a pager it has something to page).
+***************************************************************/
+function nodes_answer(data) {
+	if (Array.isArray(data)) return {
+		rows: data,
+		total: data.length,
+		pages: 1,
+		paged: false
+	};
+	if (data && typeof data === "object" && Array.isArray(data.data)) {
+		let rows = data.data;
+		return {
+			rows,
+			total: typeof data.total_rows === "number" ? data.total_rows : rows.length,
+			pages: typeof data.pages === "number" && data.pages > 0 ? data.pages : 1,
+			paged: true
+		};
+	}
+	return {
+		rows: [],
+		total: 0,
+		pages: 1,
+		paged: false
+	};
+}
+//#endregion
 //#region src/c_yui_treedb_topics.js
 /***********************************************************************
 *          c_yui_treedb_topics.js
@@ -15624,7 +15684,7 @@ function ac_mt_command_answer$2(gobj, event, kw, src) {
 			let topic_name = kw_get_str(gobj, kw_command, "topic_name", "", kw_flag_t.KW_REQUIRED);
 			if (result >= 0) {
 				let gobj_topic_form = gobj_find_child(gobj, { __gobj_name__: `${gobj_name(gobj)}?${topic_name}` });
-				gobj_send_event(gobj_topic_form, "EV_LOAD_NODES", data, gobj);
+				gobj_send_event(gobj_topic_form, "EV_LOAD_NODES", nodes_answer(data).rows, gobj);
 			}
 			break;
 		case "create-node":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yuneta/gobj-ui",
-  "version": "7.8.0",
+  "version": "7.8.1",
   "type": "module",
   "main": "dist/gobj-ui.cjs.js",
   "module": "dist/gobj-ui.es.js",

package/src/c_yui_treedb_topics.js

@@ -58,6 +58,7 @@ import "./c_yui_treedb_topics.css";
 
 import {yui_shell_show_error, yui_shell_show_modal, yui_shell_popup_layer} from "./shell_modals.js";
 import {yui_shell_of, yui_shell_set_sub_routes} from "./c_yui_shell.js";
+import {nodes_answer} from "./nodes_answer.js";
 
 import {t} from "i18next";
 
@@ -1770,10 +1771,18 @@ function ac_mt_command_answer(gobj, event, kw, src)
                 let gobj_topic_form = gobj_find_child(gobj, {
                     __gobj_name__: `${gobj_name(gobj)}?${topic_name}`
                 });
+                /*  `nodes` answers a plain list, or — when asked for a page —
+                 *  the {total_rows, pages, data} envelope. Both shapes are
+                 *  alive at once and will be for a long time: this SPA talks
+                 *  to backends the operator configures, and an older one
+                 *  answers the plain list whatever is asked of it. Reading
+                 *  the shape rather than assuming it is what keeps the table
+                 *  from rendering an object's keys as rows the day a backend
+                 *  upgrades. */
                 gobj_send_event(
                     gobj_topic_form,
                     "EV_LOAD_NODES",
-                    data,
+                    nodes_answer(data).rows,
                     gobj
                 );
             }

package/src/nodes_answer.js

@@ -0,0 +1,72 @@
+/***********************************************************************
+ *          nodes_answer.js
+ *
+ *      What the `nodes` command answered, whatever shape it came in.
+ *
+ *      A treedb lives in memory on the backend, so walking it is not
+ *      what costs: serializing every node, pushing it through a
+ *      websocket and parsing it here is. So `nodes` learned to answer a
+ *      PAGE, with the contract `list-keys` of C_TRANGER already used:
+ *
+ *          no `limit`  ->  the plain list it has always answered
+ *          a `limit`   ->  {total_rows, pages, data}
+ *
+ *      Both shapes are alive at once and will be for a long time: the
+ *      SPA talks to backends the operator configures, and an older one
+ *      answers the plain list whatever this app asks for. So the shape
+ *      is read, never assumed — a view that indexed `data` as an array
+ *      would render an object's keys as rows the day a backend
+ *      upgraded, which is the kind of break that looks like a bug in
+ *      the app.
+ *
+ *      Pure and tested, because this is exactly the sort of thing that
+ *      cannot be exercised until the other side moves.
+ *
+ *          Copyright (c) 2026, ArtGins.
+ *          All Rights Reserved.
+ ***********************************************************************/
+
+/***************************************************************
+ *  nodes_answer(data) -> {rows, total, pages, paged}
+ *
+ *  `rows` is always an array, so a caller never has to ask which
+ *  shape it got. `paged` says whether the backend answered a page,
+ *  which is the one thing a caller may legitimately care about (it is
+ *  what tells a pager it has something to page).
+ ***************************************************************/
+function nodes_answer(data)
+{
+    if(Array.isArray(data)) {
+        return {
+            rows:  data,
+            total: data.length,
+            pages: 1,
+            paged: false
+        };
+    }
+
+    if(data && typeof data === "object" && Array.isArray(data.data)) {
+        let rows = data.data;
+        let total = (typeof data.total_rows === "number")? data.total_rows : rows.length;
+        let pages = (typeof data.pages === "number" && data.pages > 0)? data.pages : 1;
+        return {
+            rows:  rows,
+            total: total,
+            pages: pages,
+            paged: true
+        };
+    }
+
+    /*  Anything else — null, an error body, a shape nobody has seen — is
+     *  no rows. The caller renders an empty table, which is honest, and
+     *  the command answer's own `result` is what says something failed. */
+    return {
+        rows:  [],
+        total: 0,
+        pages: 1,
+        paged: false
+    };
+}
+
+
+export {nodes_answer};

package/src/nodes_answer.test.js

@@ -0,0 +1,50 @@
+import {describe, it, expect} from "vitest";
+import {nodes_answer} from "./nodes_answer.js";
+
+describe("nodes_answer", () => {
+    it("reads the plain list an unpaged backend answers", () => {
+        let a = nodes_answer([{id: "a"}, {id: "b"}]);
+        expect(a.rows.length).toBe(2);
+        expect(a.total).toBe(2);
+        expect(a.pages).toBe(1);
+        expect(a.paged).toBe(false);
+    });
+
+    it("reads the envelope a paged backend answers", () => {
+        let a = nodes_answer({total_rows: 120, pages: 3, data: [{id: "a"}]});
+        expect(a.rows.length).toBe(1);
+        expect(a.total).toBe(120);
+        expect(a.pages).toBe(3);
+        expect(a.paged).toBe(true);
+    });
+
+    it("an empty page still reports the true total", () => {
+        let a = nodes_answer({total_rows: 120, pages: 3, data: []});
+        expect(a.rows).toEqual([]);
+        expect(a.total).toBe(120);
+        expect(a.paged).toBe(true);
+    });
+
+    it("an empty list is not a page", () => {
+        let a = nodes_answer([]);
+        expect(a.rows).toEqual([]);
+        expect(a.total).toBe(0);
+        expect(a.paged).toBe(false);
+    });
+
+    it("falls back to the row count when the envelope omits its totals", () => {
+        let a = nodes_answer({data: [{id: "a"}, {id: "b"}]});
+        expect(a.total).toBe(2);
+        expect(a.pages).toBe(1);
+        expect(a.paged).toBe(true);
+    });
+
+    it("gives no rows for anything it does not recognise", () => {
+        for(let bad of [null, undefined, 0, "x", {}, {data: "nope"}]) {
+            let a = nodes_answer(bad);
+            expect(a.rows).toEqual([]);
+            expect(a.total).toBe(0);
+            expect(a.paged).toBe(false);
+        }
+    });
+});