@yuneta/gobj-ui 7.25.5 → 7.25.7

package/README.md

@@ -2154,6 +2154,41 @@ else.
 - In: `EV_SHOW` (`{subpath}` — the tail it owns is `<treedb>[/<topic>]` or
   `<treedb>/diagram`), `EV_HIDE`, `EV_TRANSPORT_STATE`, `EV_REFRESH`,
   `EV_LANGUAGE_CHANGED`, `EV_MT_COMMAND_ANSWER`.
+- A **drop** of the transport — `EV_TRANSPORT_STATE {connected: false}`, or a
+  failed answer that arrives while the transport is out of `ST_SESSION` — ends
+  the load or the write it cut, and the model is asked again on the next
+  `{connected: true}`. A write cut this way is shown as
+  `the connection dropped during the write` (an i18n key the consumer's
+  locales carry). Each request carries its round in `__md_command__`
+  (`round` / `write`), so an answer of what the drop cut is ignored with a
+  warning. The drop itself is logged ONCE; the failures a routing adapter
+  settles for the same drop are that one event and are not logged again.
+- **Nothing moves the editor out of `ST_LOADING` or `ST_SAVING` but the end of
+  what is in flight** (7.25.7). An `EV_SHOW` that arrives meanwhile waits, the
+  last one wins, and it is applied when the load lands, fails or is cut, or
+  when the write ends. 7.25.6 let it move a RELOAD out of `ST_LOADING`: every
+  answer of that load was then "for a load that is over", and the next write
+  patched the records the reload had emptied into a model with no treedb.
+  With no model and no load, `EV_SHOW` keeps the position and stays in
+  `ST_IDLE`; the next load goes there.
+
+  ```js
+  gobj_send_event(editor, "EV_REFRESH", {}, host);             // ST_LOADING
+  gobj_send_event(editor, "EV_SHOW", {subpath: "db"}, host);   // waits
+  // ... the three `nodes` answers land -> ST_TOPICS of `db`
+  ```
+- A write this view gave up on (a drop, a deadline) whose answer still says it
+  was DONE makes the editor read the model again (at once, after the write in
+  flight, or on the reconnect). Through a routing adapter that settled the
+  write on its OWN deadline the late answer does not reach the view -- the
+  adapter echoes a node event instead, which this view does not hear -- and
+  Refresh is what reads the store.
+
+  ```js
+  // the host forwards its session edges; nothing else is needed
+  gobj_send_event(editor, "EV_TRANSPORT_STATE", {connected: false}, host);
+  gobj_send_event(editor, "EV_TRANSPORT_STATE", {connected: true}, host);
+  ```
 - Out: `EV_POSITION_CHANGED` (`{subpath}` — the host writes the url; this view
   navigates nothing itself), `EV_RECORD_WRITTEN` (whoever owns the Apply needs
   to know the yuno has not re-read its schema yet), `EV_SCHEMA_CHECKED`

package/dist/gobj-ui.cjs.js

@@ -3025,6 +3025,14 @@ function maybe_apply_translator($node, opts) {
 *      Non-blocking, auto-dismiss after `opts.timeout` ms (default
 *      5000).  `opts.timeout = 0` disables auto-dismiss.
 *      Returns `{ close() }` so callers can dismiss programmatically.
+*
+*      ONE toast per message on screen: a string message of the same
+*      kind as a toast still showing is not stacked under it -- that
+*      toast is kept, its time starts again, and its handle is
+*      returned. One close of a transport settles every request it
+*      cut, each view shows its failure, and the operator got a
+*      column of identical "the connection dropped". A message built
+*      of nodes is never merged: its text is not a key.
 ***************************************************************/
 function show_notification(shell, kind, message, opts) {
 	let $layer = notification_layer(shell);
@@ -3032,6 +3040,13 @@ function show_notification(shell, kind, message, opts) {
 		(0, _yuneta_gobj_js.log_warning)("yui_shell_show_*: shell has no notification layer");
 		return { close: () => {} };
 	}
+	let key = typeof message === "string" ? `${kind}\u0000${message}` : null;
+	if (key !== null) {
+		for (let $shown of Array.from($layer.children)) if ($shown.__toast_key__ === key && $shown.__toast__) {
+			$shown.__toast__.restart();
+			return $shown.__toast__.handle;
+		}
+	}
 	let p_attrs = typeof message === "string" ? { i18n: message } : {};
 	let $note = (0, _yuneta_gobj_js.createElement2)([
 		"div",
@@ -3068,8 +3083,21 @@ function show_notification(shell, kind, message, opts) {
 	let $del = $note.querySelector(".delete");
 	if ($del) $del.addEventListener("click", close);
 	let timeout = opts && opts.timeout != null ? opts.timeout : 5e3;
-	if (timeout > 0) timeout_id = setTimeout(close, timeout);
-	return { close };
+	let restart = function() {
+		if (timeout_id) {
+			clearTimeout(timeout_id);
+			timeout_id = null;
+		}
+		if (timeout > 0) timeout_id = setTimeout(close, timeout);
+	};
+	restart();
+	let handle = { close };
+	$note.__toast_key__ = key;
+	$note.__toast__ = {
+		handle,
+		restart
+	};
+	return handle;
 }
 function yui_shell_show_info(shell, message, opts) {
 	return show_notification(shell, "info", message, opts);
@@ -72101,6 +72129,12 @@ function write_options(op) {
 *      `update-node` / `delete-node` on the treedb service, and it may
 *      be a routing adapter two hops away (the agent console's
 *      C_AGENT_TREEDB_LINK) — this view cannot tell, and must not.
+*      A DROP of it (the host's EV_TRANSPORT_STATE, or a failure that
+*      arrives while the transport is out of session) ends the load or
+*      the write it cut, and the model is asked again when the session
+*      is back. Every request carries its round (`round` for a load,
+*      `write` for a write) in `__md_command__`, so an answer of what
+*      was cut is ignored instead of counted in the next one.
 *
 *          Copyright (c) 2026, ArtGins.
 *          All Rights Reserved.
@@ -72133,6 +72167,7 @@ var PRIVATE_DATA$1 = {
 	model: null,
 	pending: 0,
 	load_error: "",
+	load_round: 0,
 	treedb_id: "",
 	topic_name: "",
 	diagram: false,
@@ -72146,7 +72181,12 @@ var PRIVATE_DATA$1 = {
 	save_queue: null,
 	save_return: "",
 	save_wrote: false,
+	write_tag: 0,
 	connected: false,
+	reload_on_open: false,
+	dropped_round: 0,
+	dropped_write: 0,
+	reload_after_write: false,
 	pending_seg: null,
 	import_plan: null,
 	import_pane: null,
@@ -72317,6 +72357,7 @@ function request_model(gobj) {
 	};
 	priv.load_error = "";
 	priv.pending = 0;
+	priv.load_round++;
 	(0, _yuneta_gobj_js.gobj_change_state)(gobj, "ST_LOADING");
 	show_notice(gobj, "loading the schemas");
 	for (let topic_name of [
@@ -72326,7 +72367,7 @@ function request_model(gobj) {
 	]) if (remote_command(gobj, "nodes", {
 		topic_name,
 		options: { list_dict: true }
-	}) === 0) priv.pending++;
+	}, { round: priv.load_round }) === 0) priv.pending++;
 	if (priv.pending === 0) {
 		priv.load_error = (0, i18next.t)("cannot reach the treedb");
 		(0, _yuneta_gobj_js.gobj_change_state)(gobj, "ST_IDLE");
@@ -72344,7 +72385,7 @@ function request_model(gobj) {
 *  answer says which topic it is about, since the command is
 *  `nodes` for all three.
 ***************************************************************/
-function remote_command(gobj, command, kw) {
+function remote_command(gobj, command, kw, tag) {
 	let remote = (0, _yuneta_gobj_js.gobj_read_pointer_attr)(gobj, "gobj_remote_yuno");
 	let treedb_name = (0, _yuneta_gobj_js.gobj_read_str_attr)(gobj, "treedb_name");
 	if (!remote) {
@@ -72355,11 +72396,11 @@ function remote_command(gobj, command, kw) {
 		service: treedb_name,
 		treedb_name
 	}, kw || {});
-	full_kw.__md_command__ = {
+	full_kw.__md_command__ = Object.assign({
 		purpose: PURPOSE,
 		topic_name: kw && kw.topic_name || "",
 		record_id: kw && kw.record_id || ""
-	};
+	}, tag || {});
 	delete full_kw.record_id;
 	let ret = (0, _yuneta_gobj_js.gobj_command)(remote, command, full_kw, gobj);
 	if (ret) {
@@ -74590,12 +74631,92 @@ function run_next_write(gobj) {
 	let write = priv.save_queue[0];
 	let command = write_command(write.op);
 	let options = write_options(write.op);
+	priv.write_tag++;
 	if (remote_command(gobj, command, {
 		topic_name: write.topic_name,
 		record: write.record,
 		options,
 		record_id: write.record.id || ""
-	}) < 0) return end_writes(gobj, (0, i18next.t)("cannot reach the treedb"));
+	}, { write: priv.write_tag }) < 0) return end_writes(gobj, (0, i18next.t)("cannot reach the treedb"));
+	return 0;
+}
+/***************************************************************
+*  Does the transport say it is in session? The state the library
+*  reads off every transport (C_IEVENT_CLI and the routing adapters
+*  name it the same).
+***************************************************************/
+function transport_in_session(gobj) {
+	let remote = (0, _yuneta_gobj_js.gobj_read_pointer_attr)(gobj, "gobj_remote_yuno");
+	return !!remote && (0, _yuneta_gobj_js.gobj_current_state)(remote) === "ST_SESSION";
+}
+/***************************************************************
+*  Is this answer of the load in flight, or of the write in
+*  flight? Each request carries its round in `__md_command__`, and
+*  one the drop abandoned (or a deadline settled) can still come
+*  back: counted, it ended the next load with the old data or
+*  moved the next write's queue.
+*
+*  The state is part of the question, and that is only true
+*  because NOTHING moves the editor out of ST_LOADING or ST_SAVING
+*  but the end of what is in flight: a position the host sends
+*  meanwhile waits in `pending_seg` (ac_show()). 7.25.6 let EV_SHOW
+*  move a RELOAD out of ST_LOADING, and every answer of it was then
+*  "for a load that is over": the records it had emptied stayed
+*  empty, and the next write patched them into a model with no
+*  treedb at all.
+***************************************************************/
+function is_current_load(gobj, md) {
+	return (0, _yuneta_gobj_js.gobj_current_state)(gobj) === "ST_LOADING" && (0, _yuneta_gobj_js.kw_get_int)(gobj, md, "round", 0, 0) === gobj.priv.load_round;
+}
+function is_current_write(gobj, md) {
+	return (0, _yuneta_gobj_js.gobj_current_state)(gobj) === "ST_SAVING" && (0, _yuneta_gobj_js.kw_get_int)(gobj, md, "write", 0, 0) === gobj.priv.write_tag;
+}
+/***************************************************************
+*  The transport dropped under a load or a write: its answers
+*  will never come. The load goes back to the screen it replaced
+*  (or to "not connected" when there was none), the write ends
+*  with the drop said -- whether it landed is unknown -- and both
+*  mark the model to be asked again when the session is back.
+*  Bumping the round makes an answer of what was cut stale.
+***************************************************************/
+function transport_dropped(gobj) {
+	let priv = gobj.priv;
+	let state = (0, _yuneta_gobj_js.gobj_current_state)(gobj);
+	priv.reload_on_open = true;
+	if (state === "ST_SAVING") {
+		(0, _yuneta_gobj_js.log_warning)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: the transport dropped during a write: the model is read again on the reconnect`);
+		priv.dropped_write = priv.write_tag;
+		priv.write_tag++;
+		return end_writes(gobj, "the connection dropped during the write");
+	}
+	if (state === "ST_LOADING") {
+		(0, _yuneta_gobj_js.log_warning)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: the transport dropped during the load: the model is read again on the reconnect`);
+		priv.dropped_round = priv.load_round;
+		priv.load_round++;
+		priv.pending = 0;
+		priv.load_error = "";
+		return end_load(gobj);
+	}
+	return 0;
+}
+/***************************************************************
+*  A load is over -- landed, failed or cut -- and the editor goes
+*  where the operator is: the position the host sent while it was
+*  in flight (ac_show() kept it), or the one it had. Without a
+*  model there is no screen to go to: the position is kept for the
+*  next load, and the editor says why it is empty.
+***************************************************************/
+function end_load(gobj) {
+	let priv = gobj.priv;
+	let seg = priv.pending_seg;
+	priv.pending_seg = null;
+	if (priv.model) {
+		if (seg !== null) return apply_seg(gobj, seg);
+		return go(gobj, priv.treedb_id, priv.topic_name, priv.diagram, false);
+	}
+	if (seg !== null) adopt_seg(gobj, seg);
+	(0, _yuneta_gobj_js.gobj_change_state)(gobj, "ST_IDLE");
+	render(gobj);
 	return 0;
 }
 /***************************************************************
@@ -74618,7 +74739,7 @@ function end_writes(gobj, error) {
 			apply_seg(gobj, seg);
 			if (priv.save_wrote) (0, _yuneta_gobj_js.gobj_publish_event)(gobj, "EV_RECORD_WRITTEN", { treedb_name: (0, _yuneta_gobj_js.gobj_read_str_attr)(gobj, "treedb_name") });
 			priv.save_wrote = false;
-			return 0;
+			return reload_if_owed(gobj);
 		}
 	}
 	if (error) yui_shell_show_error(yui_shell_of(gobj), error, { t: i18next.t });
@@ -74626,9 +74747,25 @@ function end_writes(gobj, error) {
 	priv.save_wrote = false;
 	render(gobj);
 	publish_check(gobj);
+	reload_if_owed(gobj);
 	return error ? -1 : 0;
 }
 /***************************************************************
+*  A write given up earlier turned out DONE while another one was
+*  in flight (see ac_mt_command_answer()): the model is read again
+*  now that nothing is.
+***************************************************************/
+function reload_if_owed(gobj) {
+	let priv = gobj.priv;
+	if (!priv.reload_after_write) return 0;
+	priv.reload_after_write = false;
+	if (!transport_in_session(gobj)) {
+		priv.reload_on_open = true;
+		return 0;
+	}
+	return request_model(gobj);
+}
+/***************************************************************
 *  The record a column form produces.
 *
 *  Everything the store needs and the operator did not type is
@@ -74696,7 +74833,7 @@ function go(gobj, treedb_id, topic_name, diagram, mirror) {
 	priv.topic_name = topic_name || "";
 	priv.diagram = !!diagram;
 	let state = "ST_TREEDBS";
-	if (!priv.model) state = "ST_LOADING";
+	if (!priv.model) state = "ST_IDLE";
 	else if (priv.model.treedbs.length === 0) state = "ST_EMPTY";
 	else if (priv.treedb_id && priv.diagram) state = "ST_DIAGRAM";
 	else if (priv.treedb_id && priv.topic_name) state = "ST_COLUMNS";
@@ -74723,12 +74860,39 @@ function position_seg(gobj) {
 *  empty screen: a shared link outlives the schema it points at.
 ***************************************************************/
 function apply_seg(gobj, seg) {
+	let pos = seg_position(seg);
+	return go(gobj, pos.treedb_id, pos.topic_name, pos.diagram, false);
+}
+function seg_position(seg) {
 	let parts = String(seg || "").split("/").filter((x) => x.length > 0);
 	let treedb_id = parts[0] || "";
 	let tail = parts[1] || "";
-	if (!treedb_id) return go(gobj, "", "", false, false);
-	if (tail === DIAGRAM_SEG) return go(gobj, treedb_id, "", true, false);
-	return go(gobj, treedb_id, tail, false, false);
+	if (!treedb_id) return {
+		treedb_id: "",
+		topic_name: "",
+		diagram: false
+	};
+	if (tail === DIAGRAM_SEG) return {
+		treedb_id,
+		topic_name: "",
+		diagram: true
+	};
+	return {
+		treedb_id,
+		topic_name: tail,
+		diagram: false
+	};
+}
+/***************************************************************
+*  Where the operator is, taken WITHOUT a screen: there is no model
+*  to draw it on yet, and the load that brings one goes there.
+***************************************************************/
+function adopt_seg(gobj, seg) {
+	let priv = gobj.priv;
+	let pos = seg_position(seg);
+	priv.treedb_id = pos.treedb_id;
+	priv.topic_name = pos.topic_name;
+	priv.diagram = pos.diagram;
 }
 /***************************
 *      Actions
@@ -74750,25 +74914,39 @@ function ac_mt_command_answer(gobj, event, kw, src) {
 	let kw_command = (0, _yuneta_gobj_js.kw_get_dict)(gobj, __command__, "kw", {}, 0);
 	let md = (0, _yuneta_gobj_js.is_object)(kw_command.__md_command__) ? kw_command.__md_command__ : kw_command;
 	if ((0, _yuneta_gobj_js.kw_get_str)(gobj, md, "purpose", "", 0) !== PURPOSE) return 0;
+	if (result < 0 && !transport_in_session(gobj) && ((0, _yuneta_gobj_js.gobj_current_state)(gobj) === "ST_LOADING" || (0, _yuneta_gobj_js.gobj_current_state)(gobj) === "ST_SAVING")) {
+		if (command === "nodes" && is_current_load(gobj, md) || command !== "nodes" && is_current_write(gobj, md)) return transport_dropped(gobj);
+	}
 	if (command === "nodes") {
 		let topic_name = (0, _yuneta_gobj_js.kw_get_str)(gobj, md, "topic_name", "", 0);
+		if (!is_current_load(gobj, md)) {
+			if (result < 0 && (0, _yuneta_gobj_js.kw_get_int)(gobj, md, "round", 0, 0) === priv.dropped_round) return 0;
+			(0, _yuneta_gobj_js.log_warning)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: 'nodes' of '${topic_name}' answered for a load that is over: ignored`);
+			return 0;
+		}
 		priv.pending--;
 		if (result < 0) priv.load_error = comment || (0, i18next.t)("cannot load the schemas");
 		else if (priv.records && Array.isArray(priv.records[topic_name])) priv.records[topic_name] = Array.isArray(data) ? data : [];
 		if (priv.pending > 0) return 0;
 		if (priv.load_error) {
 			priv.model = null;
-			(0, _yuneta_gobj_js.gobj_change_state)(gobj, "ST_IDLE");
-			render(gobj);
-			return 0;
+			return end_load(gobj);
 		}
 		priv.order_undo = {};
 		build_model(gobj);
 		start_measuring(gobj);
-		return go(gobj, priv.treedb_id, priv.topic_name, priv.diagram, false);
+		return end_load(gobj);
 	}
 	if (command === "update-node" || command === "delete-node") {
 		let topic_name = (0, _yuneta_gobj_js.kw_get_str)(gobj, md, "topic_name", "", 0);
+		if (!is_current_write(gobj, md)) {
+			if (result < 0 && (0, _yuneta_gobj_js.kw_get_int)(gobj, md, "write", 0, 0) === priv.dropped_write) return 0;
+			if (result < 0) {
+				(0, _yuneta_gobj_js.log_warning)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: '${command}' of '${topic_name}' answered for a write that is over (result ${result}): ignored`);
+				return 0;
+			}
+			return late_write_done(gobj, command, topic_name);
+		}
 		if (result < 0) return end_writes(gobj, comment || (0, i18next.t)("the treedb refused the write"));
 		priv.save_wrote = true;
 		if (command === "delete-node") forget_record(gobj, topic_name, (0, _yuneta_gobj_js.kw_get_str)(gobj, md, "record_id", "", 0));
@@ -74793,6 +74971,35 @@ function ac_mt_command_answer(gobj, event, kw, src) {
 	return 0;
 }
 /***************************************************************
+*  A write this view gave up on (a drop, a deadline) answers that
+*  it was DONE: the store holds a change the model does not show.
+*  The model is read again -- now, or when what is in flight ends,
+*  or on the reconnect. A load in flight needs nothing: it was
+*  asked after the write, on the same transport, and reads it.
+*
+*  Only when the answer reaches this view. A routing adapter that
+*  settled the write on its own deadline (gui_agent's
+*  C_AGENT_TREEDB_LINK) does not deliver its late answer again --
+*  the view was answered once, as failed -- and echoes the node
+*  event instead, which this view does not hear: there, Refresh is
+*  what reads the store.
+***************************************************************/
+function late_write_done(gobj, command, topic_name) {
+	let priv = gobj.priv;
+	let state = (0, _yuneta_gobj_js.gobj_current_state)(gobj);
+	(0, _yuneta_gobj_js.log_warning)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: '${command}' of '${topic_name}' was given up, and it was DONE: the model is read again`);
+	if (state === "ST_LOADING") return 0;
+	if (state === "ST_SAVING") {
+		priv.reload_after_write = true;
+		return 0;
+	}
+	if (!transport_in_session(gobj)) {
+		priv.reload_on_open = true;
+		return 0;
+	}
+	return request_model(gobj);
+}
+/***************************************************************
 *  Remember which topic this write belongs to, which is what
 *  "its version still has to move" is asked about.
 ***************************************************************/
@@ -74812,7 +75019,8 @@ function mark_written(gobj, topic_name, record) {
 function ac_show(gobj, event, kw, src) {
 	let priv = gobj.priv;
 	let seg = kw && kw.subpath || "";
-	if ((0, _yuneta_gobj_js.gobj_current_state)(gobj) === "ST_SAVING") {
+	let state = (0, _yuneta_gobj_js.gobj_current_state)(gobj);
+	if (state === "ST_SAVING" || state === "ST_LOADING") {
 		priv.pending_seg = seg;
 		return 0;
 	}
@@ -74828,14 +75036,28 @@ function ac_hide(gobj, event, kw, src) {
 	return 0;
 }
 /***************************************************************
-*  The session came up or went down. The model stays either way
-*  — a schema does not change under you — but a first load may
-*  have had no transport to run on.
+*  The session came up or went down. The model stays -- a schema
+*  does not change under you -- unless the drop cut a load or a
+*  write (transport_dropped()): then it is asked again on the way
+*  back, as it is when a first load had no transport to run on.
+*
+*  Nothing else ends a load or a write the drop cut: their answers
+*  will never come, and waiting in ST_LOADING skipped the reload
+*  itself (M-1 of the independent review of 7.25.4).
 ***************************************************************/
 function ac_transport_state(gobj, event, kw, src) {
 	let priv = gobj.priv;
+	let state = (0, _yuneta_gobj_js.gobj_current_state)(gobj);
 	priv.connected = !!(kw && kw.connected);
-	if (priv.connected && !priv.model && (0, _yuneta_gobj_js.gobj_current_state)(gobj) !== "ST_LOADING") return request_model(gobj);
+	if (!priv.connected) {
+		if (state === "ST_LOADING" || state === "ST_SAVING") return transport_dropped(gobj);
+		render_toolbar(gobj);
+		return 0;
+	}
+	if ((!priv.model || priv.reload_on_open) && state !== "ST_LOADING" && state !== "ST_SAVING") {
+		priv.reload_on_open = false;
+		return request_model(gobj);
+	}
 	render_toolbar(gobj);
 	return 0;
 }