@yuneta/gobj-ui 7.25.7 → 7.25.8

package/README.md

@@ -2177,9 +2177,24 @@ else.
   gobj_send_event(editor, "EV_SHOW", {subpath: "db"}, host);   // waits
   // ... the three `nodes` answers land -> ST_TOPICS of `db`
   ```
+- **The loading screen is drawn** (7.25.8): the body is cleared, the drawing
+  destroyed and every toolbar button disabled, as in `ST_SAVING`, because
+  `ST_LOADING` declares none of a screen's actions. A **dialog** left open is
+  the one thing still reachable: its Save (`EV_SAVE_COLUMN`, `EV_SAVE_TOPIC`),
+  a confirmation (`EV_CONFIRMED`), an orphan delete or an import is refused
+  with `the schemas are loading: try again when they are in` (an i18n key the
+  consumer's locales carry) and the dialog stays open with what was typed, so
+  the same Save works once the load is in. A write that ends with an error --
+  a drop included -- still applies a position that waited, as a load does.
+  Out of session a load is not asked at all (no *"not in session"* errors);
+  the reconnect loads.
 - 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
+  flight, or on the reconnect), and it is a write for the host too: it
+  publishes `EV_RECORD_WRITTEN` and marks the topic of the record answered.
+  Only the host's `EV_REFRESH` (a Save sends it) forgets what this session
+  wrote; the reloads the editor asks itself (the reconnect's, a late write's)
+  keep the draft chips. 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.
@@ -2614,6 +2629,22 @@ live region it is both read and announced when it changes.
 > long time and nothing ever rendered it; the claim is gone. Implement it there
 > the day a menu entry needs one.
 
+### Toasts — `yui_shell_show_info` / `_warning` / `_error`
+
+`yui_shell_show_error(shell, "key", {t, timeout})` shows a non-blocking toast
+(5000 ms by default, `timeout: 0` = until closed) and returns `{close()}`. A
+string message of the same kind as a toast still on screen is not stacked
+under it -- there is ONE toast per message -- but each call is a caller of its
+own: it gets its own handle and its own time, and the toast goes when every
+caller has closed its handle or timed out (7.25.8). The ✕ closes it for all.
+
+```js
+const a = yui_shell_show_error(shell, "the connection dropped", {t});             // 5 s
+const b = yui_shell_show_error(shell, "the connection dropped", {t, timeout: 0}); // same toast
+a.close();          // still shown: b holds it
+b.close();          // gone
+```
+
 ### Modals — `yui_shell_show_modal` and the `before_close` veto
 
 `yui_shell_show_modal(shell, $box, opts)` is the standard popup: pass

package/dist/gobj-ui.cjs.js

@@ -3027,12 +3027,20 @@ function maybe_apply_translator($node, opts) {
 *      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.
+*      kind as a toast still showing is not stacked under it. 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.
+*
+*      A repeat is still a CALLER of its own: it gets its own handle
+*      and its own time, and the toast stays while any caller holds
+*      it -- until every handle is closed or has timed out. Handed the
+*      first caller's handle and timer, a repeat asking `timeout: 0`
+*      was dismissed on the first one's timer, and closing one
+*      caller's handle closed a toast another was still showing
+*      (third independent review). The operator's ✕ closes it for
+*      everybody.
 ***************************************************************/
 function show_notification(shell, kind, message, opts) {
 	let $layer = notification_layer(shell);
@@ -3040,12 +3048,10 @@ function show_notification(shell, kind, message, opts) {
 		(0, _yuneta_gobj_js.log_warning)("yui_shell_show_*: shell has no notification layer");
 		return { close: () => {} };
 	}
+	let timeout = opts && opts.timeout != null ? opts.timeout : 5e3;
 	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;
-		}
+		for (let $shown of Array.from($layer.children)) if ($shown.__toast_key__ === key && $shown.__toast__) return $shown.__toast__.hold(timeout);
 	}
 	let p_attrs = typeof message === "string" ? { i18n: message } : {};
 	let $note = (0, _yuneta_gobj_js.createElement2)([
@@ -3069,35 +3075,38 @@ function show_notification(shell, kind, message, opts) {
 	]);
 	$layer.appendChild($note);
 	maybe_apply_translator($note, opts);
-	let timeout_id = null;
+	let holders = /* @__PURE__ */ new Set();
 	let closed = false;
-	let close = function() {
+	let close_toast = function() {
 		if (closed) return;
 		closed = true;
-		if (timeout_id) {
-			clearTimeout(timeout_id);
-			timeout_id = null;
+		for (let holder of holders) if (holder.timeout_id) {
+			clearTimeout(holder.timeout_id);
+			holder.timeout_id = null;
 		}
+		holders.clear();
 		if ($note.parentNode) $note.parentNode.removeChild($note);
 	};
-	let $del = $note.querySelector(".delete");
-	if ($del) $del.addEventListener("click", close);
-	let timeout = opts && opts.timeout != null ? opts.timeout : 5e3;
-	let restart = function() {
-		if (timeout_id) {
-			clearTimeout(timeout_id);
-			timeout_id = null;
-		}
-		if (timeout > 0) timeout_id = setTimeout(close, timeout);
+	let hold = function(ms) {
+		let holder = { timeout_id: null };
+		let release = function() {
+			if (!holders.has(holder)) return;
+			if (holder.timeout_id) {
+				clearTimeout(holder.timeout_id);
+				holder.timeout_id = null;
+			}
+			holders.delete(holder);
+			if (holders.size === 0) close_toast();
+		};
+		holders.add(holder);
+		if (ms > 0) holder.timeout_id = setTimeout(release, ms);
+		return { close: release };
 	};
-	restart();
-	let handle = { close };
+	let $del = $note.querySelector(".delete");
+	if ($del) $del.addEventListener("click", close_toast);
 	$note.__toast_key__ = key;
-	$note.__toast__ = {
-		handle,
-		restart
-	};
-	return handle;
+	$note.__toast__ = { hold };
+	return hold(timeout);
 }
 function yui_shell_show_info(shell, message, opts) {
 	return show_notification(shell, "info", message, opts);
@@ -72168,6 +72177,7 @@ var PRIVATE_DATA$1 = {
 	pending: 0,
 	load_error: "",
 	load_round: 0,
+	load_keeps_written: false,
 	treedb_id: "",
 	topic_name: "",
 	diagram: false,
@@ -72346,10 +72356,28 @@ function refuse_if_readonly(gobj, event) {
 *  schema set of the yuno is here: everything below — the
 *  drawing, the validation, the export — is computed from these
 *  and asks the backend nothing more.
+*
+*  THE LOADING SCREEN IS DRAWN, not assumed. ST_LOADING declares
+*  none of the actions of a screen, so the screen it replaces goes
+*  and the toolbar stops answering: left up, a click on a card, on
+*  Back or on the drawing answered "Event NOT DEFINED in state
+*  ST_LOADING" and was lost (third independent review). A dialog
+*  left open is answered in ST_LOADING instead (ac_wait_for_the_load).
+*
+*  `keep_written`: a load the host did not ask for -- the reconnect,
+*  a write that turned out done -- keeps what this session wrote.
+*  Only the host's EV_REFRESH (a Save sends it) forgets it.
+*
+*  A load that cannot leave WHOLE did not happen (out of session it
+*  is not even asked): the records the model was built on are put
+*  back (emptied, the next write patched them into a model with no
+*  treedb), the round is spent so a request that did leave is
+*  stale, and the session back asks again.
 ***************************************************************/
-function request_model(gobj) {
+function request_model(gobj, keep_written) {
 	let priv = gobj.priv;
 	if (!(0, _yuneta_gobj_js.gobj_read_pointer_attr)(gobj, "gobj_remote_yuno")) return -1;
+	let previous = priv.records;
 	priv.records = {
 		treedbs: [],
 		topics: [],
@@ -72358,22 +72386,31 @@ function request_model(gobj) {
 	priv.load_error = "";
 	priv.pending = 0;
 	priv.load_round++;
+	priv.load_keeps_written = !!keep_written;
 	(0, _yuneta_gobj_js.gobj_change_state)(gobj, "ST_LOADING");
-	show_notice(gobj, "loading the schemas");
-	for (let topic_name of [
-		T_TREEDBS,
-		T_TOPICS,
-		T_COLS
-	]) if (remote_command(gobj, "nodes", {
-		topic_name,
-		options: { list_dict: true }
-	}, { round: priv.load_round }) === 0) priv.pending++;
-	if (priv.pending === 0) {
+	set_busy(gobj, false);
+	render(gobj);
+	let left = 0;
+	if (transport_in_session(gobj)) {
+		for (let topic_name of [
+			T_TREEDBS,
+			T_TOPICS,
+			T_COLS
+		]) if (remote_command(gobj, "nodes", {
+			topic_name,
+			options: { list_dict: true }
+		}, { round: priv.load_round }) === 0) left++;
+	}
+	if (left < 3) {
+		priv.records = previous;
+		priv.load_round++;
+		priv.reload_on_open = true;
 		priv.load_error = (0, i18next.t)("cannot reach the treedb");
-		(0, _yuneta_gobj_js.gobj_change_state)(gobj, "ST_IDLE");
-		show_notice(gobj, "cannot reach the treedb");
+		if (priv.model) yui_shell_show_error(yui_shell_of(gobj), "cannot reach the treedb", { t: i18next.t });
+		end_load(gobj);
 		return -1;
 	}
+	priv.pending = left;
 	return 0;
 }
 /***************************************************************
@@ -72436,15 +72473,19 @@ function build_model(gobj) {
 *  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.
+*  measurement of "changed since" can be measured against.
+*
+*  `written` is forgotten only by a load the HOST asked for (its
+*  EV_REFRESH, which a Save sends). Since M36 a write moves no
+*  version, so `written` is the draft chip of what this session
+*  wrote and no longer half of a version measurement: a reload of
+*  the reconnect, or of a write that turned out done, forgot the
+*  chips of writes the host had not been told about.
 ***************************************************************/
 function start_measuring(gobj) {
 	let priv = gobj.priv;
 	priv.baseline = {};
-	priv.written = {};
+	if (!priv.load_keeps_written) priv.written = {};
 	priv.host_ids = {};
 	if (!priv.model) return;
 	for (let treedb of priv.model.treedbs) for (let topic of treedb.topics) priv.baseline[topic.id] = topic.topic_version;
@@ -72626,8 +72667,10 @@ function render_toolbar(gobj) {
 	let state = (0, _yuneta_gobj_js.gobj_current_state)(gobj);
 	let readonly = is_readonly(gobj);
 	let has_model = !!priv.model;
+	let on_a_treedb = state !== "ST_IDLE" && state !== "ST_EMPTY";
+	let in_flight = state === "ST_SAVING" || state === "ST_LOADING";
 	let $left = [];
-	if (priv.treedb_id) $left.push([
+	if (priv.treedb_id && on_a_treedb) $left.push([
 		"button",
 		{
 			class: "SCHEMA_BACK button",
@@ -72700,17 +72743,17 @@ function render_toolbar(gobj) {
 		$trail
 	]);
 	let $right = [];
-	if (priv.treedb_id && has_model) {
+	if (priv.treedb_id && has_model && on_a_treedb) {
 		$right.push(toolbar_button("SCHEMA_DIAGRAM_BTN", "yi-compass-drafting", priv.diagram ? "topics" : "diagram", "EV_TOGGLE_DIAGRAM", false));
 		$right.push(toolbar_button("SCHEMA_VALIDATE_BTN", "yi-square-check", "check", "EV_VALIDATE", false));
 		$right.push(toolbar_button("SCHEMA_EXPORT_BTN", "yi-download", "export", "EV_EXPORT", false));
 		if (!readonly) $right.push(toolbar_button("SCHEMA_IMPORT_BTN", "yi-upload", "import", "EV_IMPORT", false));
 	}
-	if (priv.topic_name && !readonly && !priv.diagram) {
+	if (priv.topic_name && !readonly && !priv.diagram && on_a_treedb) {
 		if (undo_order_writes(gobj, current_topic(gobj)).length > 0) $right.push(toolbar_button("SCHEMA_UNDO_ORDER_BTN", "yi-arrow-rotate-left", "undo the order", "EV_UNDO_ORDER", false));
 		$right.push(toolbar_button("SCHEMA_ADD_COL_BTN", "yi-plus", "new column", "EV_ADD_COLUMN", false));
 	}
-	if (priv.treedb_id && !priv.topic_name && !readonly && !priv.diagram) $right.push(toolbar_button("SCHEMA_ADD_TOPIC_BTN", "yi-plus", "new topic", "EV_ADD_TOPIC", false));
+	if (priv.treedb_id && !priv.topic_name && !readonly && !priv.diagram && on_a_treedb) $right.push(toolbar_button("SCHEMA_ADD_TOPIC_BTN", "yi-plus", "new topic", "EV_ADD_TOPIC", false));
 	$right.push(toolbar_button("SCHEMA_REFRESH_BTN", "yi-arrows-rotate", "refresh", "EV_REFRESH", state === "ST_LOADING"));
 	let $bar = (0, _yuneta_gobj_js.createElement2)([
 		"div",
@@ -72736,7 +72779,7 @@ function render_toolbar(gobj) {
 	]);
 	for (let $button of $bar.querySelectorAll("button")) {
 		$button.__gobj__ = gobj;
-		if (state === "ST_SAVING") $button.disabled = true;
+		if (in_flight) $button.disabled = true;
 	}
 	$toolbar.appendChild($bar);
 	(0, _yuneta_gobj_js.refresh_language)($toolbar, i18next.t);
@@ -72754,16 +72797,19 @@ function render(gobj) {
 	render_toolbar(gobj);
 	if (state === "ST_LOADING") {
 		show_notice(gobj, "loading the schemas");
+		destroy_diagram(gobj);
 		clear($body);
 		return;
 	}
 	if (state === "ST_IDLE") {
 		show_notice(gobj, priv.load_error ? "cannot load the schemas" : "not connected", priv.load_error);
+		destroy_diagram(gobj);
 		clear($body);
 		return;
 	}
 	if (state === "ST_EMPTY") {
 		show_notice(gobj, "this yuno stores no schema");
+		destroy_diagram(gobj);
 		clear($body);
 		return;
 	}
@@ -73452,12 +73498,16 @@ function render_diagram(gobj) {
 	let priv = gobj.priv;
 	let $body = $of(gobj, ".SCHEMA_BODY");
 	let treedb = current_treedb(gobj);
-	if (!$body || !treedb) {
+	if (!$body) return;
+	if (!treedb) {
+		destroy_diagram(gobj);
+		clear($body);
 		show_notice(gobj, "that treedb is not here any more", priv.treedb_id);
 		return;
 	}
 	if (!(0, _yuneta_gobj_js.gclass_find_by_name)("C_YUI_TREEDB_SCHEMA")) {
 		(0, _yuneta_gobj_js.log_error)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: C_YUI_TREEDB_SCHEMA not registered by the app`);
+		clear($body);
 		show_notice(gobj, "the schema drawing is not available");
 		return;
 	}
@@ -74727,26 +74777,21 @@ function end_load(gobj) {
 ***************************************************************/
 function end_writes(gobj, error) {
 	let priv = gobj.priv;
+	let seg = priv.pending_seg;
 	priv.save_queue = [];
+	priv.pending_seg = null;
 	(0, _yuneta_gobj_js.gobj_change_state)(gobj, priv.save_return || "ST_TREEDBS");
 	priv.save_return = "";
 	show_notice(gobj, "");
 	set_busy(gobj, false);
-	if (priv.pending_seg !== null) {
-		let seg = priv.pending_seg;
-		priv.pending_seg = null;
-		if (!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 reload_if_owed(gobj);
-		}
-	}
 	if (error) yui_shell_show_error(yui_shell_of(gobj), error, { t: i18next.t });
 	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;
-	render(gobj);
-	publish_check(gobj);
+	if (seg !== null) apply_seg(gobj, seg);
+	else {
+		render(gobj);
+		publish_check(gobj);
+	}
 	reload_if_owed(gobj);
 	return error ? -1 : 0;
 }
@@ -74763,7 +74808,7 @@ function reload_if_owed(gobj) {
 		priv.reload_on_open = true;
 		return 0;
 	}
-	return request_model(gobj);
+	return request_model(gobj, true);
 }
 /***************************************************************
 *  The record a column form produces.
@@ -74829,6 +74874,7 @@ function topic_record(gobj, treedb, topic, values) {
 ***************************************************************/
 function go(gobj, treedb_id, topic_name, diagram, mirror) {
 	let priv = gobj.priv;
+	priv.pending_seg = null;
 	priv.treedb_id = treedb_id || "";
 	priv.topic_name = topic_name || "";
 	priv.diagram = !!diagram;
@@ -74945,7 +74991,7 @@ function ac_mt_command_answer(gobj, event, kw, src) {
 				(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);
+			return late_write_done(gobj, command, topic_name, data);
 		}
 		if (result < 0) return end_writes(gobj, comment || (0, i18next.t)("the treedb refused the write"));
 		priv.save_wrote = true;
@@ -74955,8 +75001,15 @@ function ac_mt_command_answer(gobj, event, kw, src) {
 			if (record) patch_record(gobj, topic_name, record);
 			else {
 				(0, _yuneta_gobj_js.log_warning)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: '${command}' answered no record`);
+				if (topic_name === T_TOPICS || topic_name === T_COLS) {
+					let write = priv.save_queue[0];
+					mark_written(gobj, topic_name, write ? write.record : null);
+				}
 				priv.save_queue = [];
-				request_model(gobj);
+				priv.save_return = "";
+				priv.save_wrote = false;
+				(0, _yuneta_gobj_js.gobj_publish_event)(gobj, "EV_RECORD_WRITTEN", { treedb_name: (0, _yuneta_gobj_js.gobj_read_str_attr)(gobj, "treedb_name") });
+				request_model(gobj, true);
 				return 0;
 			}
 		}
@@ -74983,11 +75036,18 @@ function ac_mt_command_answer(gobj, event, kw, src) {
 *  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.
+*
+*  It is a WRITE like any other for the host (EV_RECORD_WRITTEN):
+*  the host was told nothing when it was given up, and it owns the
+*  Save that publishes it. The reload keeps what this session wrote
+*  (request_model()), and the record it answered marks its topic.
 ***************************************************************/
-function late_write_done(gobj, command, topic_name) {
+function late_write_done(gobj, command, topic_name, data) {
 	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`);
+	mark_written_record(gobj, topic_name, (0, _yuneta_gobj_js.is_object)(data) ? data : Array.isArray(data) && (0, _yuneta_gobj_js.is_object)(data[0]) ? data[0] : null);
+	(0, _yuneta_gobj_js.gobj_publish_event)(gobj, "EV_RECORD_WRITTEN", { treedb_name: (0, _yuneta_gobj_js.gobj_read_str_attr)(gobj, "treedb_name") });
 	if (state === "ST_LOADING") return 0;
 	if (state === "ST_SAVING") {
 		priv.reload_after_write = true;
@@ -74997,7 +75057,27 @@ function late_write_done(gobj, command, topic_name) {
 		priv.reload_on_open = true;
 		return 0;
 	}
-	return request_model(gobj);
+	return request_model(gobj, true);
+}
+/***************************************************************
+*  The topic a record written belongs to, read off the RECORD and
+*  not off the screen: a write answered late may be about a topic
+*  the operator has left. A column names its topic in its fkey
+*  (`topics^<topic id>^cols`); a topic is its own id.
+***************************************************************/
+function mark_written_record(gobj, topic_name, record) {
+	let priv = gobj.priv;
+	if (!record) return;
+	if (topic_name === T_TOPICS && typeof record.id === "string" && record.id) {
+		priv.written[record.id] = true;
+		return;
+	}
+	if (topic_name !== T_COLS) return;
+	let refs = Array.isArray(record.topics) ? record.topics : typeof record.topics === "string" ? [record.topics] : [];
+	for (let ref of refs) {
+		let parts = String(ref).split("^");
+		if (parts.length >= 2 && parts[1]) priv.written[parts[1]] = true;
+	}
 }
 /***************************************************************
 *  Remember which topic this write belongs to, which is what
@@ -75056,7 +75136,7 @@ function ac_transport_state(gobj, event, kw, src) {
 	}
 	if ((!priv.model || priv.reload_on_open) && state !== "ST_LOADING" && state !== "ST_SAVING") {
 		priv.reload_on_open = false;
-		return request_model(gobj);
+		return request_model(gobj, true);
 	}
 	render_toolbar(gobj);
 	return 0;
@@ -75071,7 +75151,25 @@ function ac_language_changed$1(gobj, event, kw, src) {
 	return 0;
 }
 function ac_refresh$1(gobj, event, kw, src) {
-	return request_model(gobj);
+	return request_model(gobj, false);
+}
+/***************************************************************
+*  What a DIALOG sends while the model is being read again: the
+*  Save of a form left open when the reload started, a
+*  confirmation, an import. The loading screen took the rest of
+*  the view away (request_model()); a dialog is the one thing the
+*  operator can still reach, and what it asks is computed against
+*  a model the answers in the air are about to replace.
+*
+*  Refused, and SAID -- and the dialog stays open with what was
+*  typed, so the same Save works once the load is in. Undeclared,
+*  it answered "Event NOT DEFINED in state ST_LOADING" and the
+*  edit was gone with no word (third independent review).
+***************************************************************/
+function ac_wait_for_the_load(gobj, event, kw, src) {
+	(0, _yuneta_gobj_js.log_warning)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: ${event} refused, the schemas are loading`);
+	yui_shell_show_error(yui_shell_of(gobj), "the schemas are loading: try again when they are in", { t: i18next.t });
+	return -1;
 }
 /***************************************************************
 *  {drafts: {treedb_name: [topic names]}} -- the host says which
@@ -75619,7 +75717,38 @@ function create_gclass$1(gclass_name) {
 	];
 	const states = [
 		["ST_IDLE", COMMON.slice()],
-		["ST_LOADING", COMMON.slice()],
+		["ST_LOADING", COMMON.concat([
+			[
+				"EV_SAVE_COLUMN",
+				ac_wait_for_the_load,
+				null
+			],
+			[
+				"EV_SAVE_TOPIC",
+				ac_wait_for_the_load,
+				null
+			],
+			[
+				"EV_DELETE_ORPHAN",
+				ac_wait_for_the_load,
+				null
+			],
+			[
+				"EV_PREVIEW_IMPORT",
+				ac_wait_for_the_load,
+				null
+			],
+			[
+				"EV_APPLY_IMPORT",
+				ac_wait_for_the_load,
+				null
+			],
+			[
+				"EV_CONFIRMED",
+				ac_wait_for_the_load,
+				null
+			]
+		])],
 		["ST_EMPTY", COMMON.slice()],
 		["ST_TREEDBS", COMMON.concat([
 			[