@yuneta/gobj-ui 7.25.5 → 7.25.7

package/dist/gobj-ui.es.js

@@ -3020,6 +3020,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);
@@ -3027,6 +3035,13 @@ function show_notification(shell, kind, message, opts) {
 		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 = createElement2([
 		"div",
@@ -3063,8 +3078,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);
@@ -72096,6 +72124,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.
@@ -72128,6 +72162,7 @@ var PRIVATE_DATA$1 = {
 	model: null,
 	pending: 0,
 	load_error: "",
+	load_round: 0,
 	treedb_id: "",
 	topic_name: "",
 	diagram: false,
@@ -72141,7 +72176,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,
@@ -72312,6 +72352,7 @@ function request_model(gobj) {
 	};
 	priv.load_error = "";
 	priv.pending = 0;
+	priv.load_round++;
 	gobj_change_state(gobj, "ST_LOADING");
 	show_notice(gobj, "loading the schemas");
 	for (let topic_name of [
@@ -72321,7 +72362,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 = t("cannot reach the treedb");
 		gobj_change_state(gobj, "ST_IDLE");
@@ -72339,7 +72380,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 = gobj_read_pointer_attr(gobj, "gobj_remote_yuno");
 	let treedb_name = gobj_read_str_attr(gobj, "treedb_name");
 	if (!remote) {
@@ -72350,11 +72391,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 = gobj_command(remote, command, full_kw, gobj);
 	if (ret) {
@@ -74585,12 +74626,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, t("cannot reach the treedb"));
+	}, { write: priv.write_tag }) < 0) return end_writes(gobj, 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 = gobj_read_pointer_attr(gobj, "gobj_remote_yuno");
+	return !!remote && 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 gobj_current_state(gobj) === "ST_LOADING" && kw_get_int(gobj, md, "round", 0, 0) === gobj.priv.load_round;
+}
+function is_current_write(gobj, md) {
+	return gobj_current_state(gobj) === "ST_SAVING" && 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 = gobj_current_state(gobj);
+	priv.reload_on_open = true;
+	if (state === "ST_SAVING") {
+		log_warning(`${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") {
+		log_warning(`${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);
+	gobj_change_state(gobj, "ST_IDLE");
+	render(gobj);
 	return 0;
 }
 /***************************************************************
@@ -74613,7 +74734,7 @@ function end_writes(gobj, error) {
 			apply_seg(gobj, seg);
 			if (priv.save_wrote) gobj_publish_event(gobj, "EV_RECORD_WRITTEN", { treedb_name: 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 });
@@ -74621,9 +74742,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
@@ -74691,7 +74828,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";
@@ -74718,12 +74855,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
@@ -74745,25 +74909,39 @@ function ac_mt_command_answer(gobj, event, kw, src) {
 	let kw_command = kw_get_dict(gobj, __command__, "kw", {}, 0);
 	let md = is_object(kw_command.__md_command__) ? kw_command.__md_command__ : kw_command;
 	if (kw_get_str(gobj, md, "purpose", "", 0) !== PURPOSE) return 0;
+	if (result < 0 && !transport_in_session(gobj) && (gobj_current_state(gobj) === "ST_LOADING" || 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 = kw_get_str(gobj, md, "topic_name", "", 0);
+		if (!is_current_load(gobj, md)) {
+			if (result < 0 && kw_get_int(gobj, md, "round", 0, 0) === priv.dropped_round) return 0;
+			log_warning(`${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 || 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;
-			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 = kw_get_str(gobj, md, "topic_name", "", 0);
+		if (!is_current_write(gobj, md)) {
+			if (result < 0 && kw_get_int(gobj, md, "write", 0, 0) === priv.dropped_write) return 0;
+			if (result < 0) {
+				log_warning(`${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 || t("the treedb refused the write"));
 		priv.save_wrote = true;
 		if (command === "delete-node") forget_record(gobj, topic_name, kw_get_str(gobj, md, "record_id", "", 0));
@@ -74788,6 +74966,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 = gobj_current_state(gobj);
+	log_warning(`${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.
 ***************************************************************/
@@ -74807,7 +75014,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 (gobj_current_state(gobj) === "ST_SAVING") {
+	let state = gobj_current_state(gobj);
+	if (state === "ST_SAVING" || state === "ST_LOADING") {
 		priv.pending_seg = seg;
 		return 0;
 	}
@@ -74823,14 +75031,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 = gobj_current_state(gobj);
 	priv.connected = !!(kw && kw.connected);
-	if (priv.connected && !priv.model && 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;
 }

package/package.json

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