@yuneta/gobj-js 7.26.26 → 7.26.28

package/dist/gobj-js.umd.js

@@ -1952,6 +1952,31 @@
 		}
 	}
 	/************************************************************
+	*  The SDF_REQUIRED attributes with no value, or null when there
+	*  is none: what is empty is asked type by type, as in C.
+	************************************************************/
+	function gobj_check_required_attrs(gobj) {
+		const hs = gobj_hsdata(gobj);
+		const missing = [];
+		if (!is_array(gobj.gclass.attrs_table)) return null;
+		for (const it of gobj.gclass.attrs_table) {
+			if (!it.name || !(it.flag & sdata_flag_t.SDF_REQUIRED)) continue;
+			const value = hs[it.name];
+			switch (it.type) {
+				case data_type_t.DTP_STRING:
+					if (!is_string(value) || empty_string(value)) missing.push(it.name);
+					break;
+				case data_type_t.DTP_LIST:
+				case data_type_t.DTP_DICT:
+				case data_type_t.DTP_JSON:
+					if (empty_json(value)) missing.push(it.name);
+					break;
+				case data_type_t.DTP_POINTER: if (!value) missing.push(it.name);
+			}
+		}
+		return missing.length ? missing : null;
+	}
+	/************************************************************
 	*
 	************************************************************/
 	function gobj_start(gobj) {
@@ -1967,6 +1992,11 @@
 			log_error(`${gobj_short_name(gobj)}: GObj DISABLED`);
 			return -1;
 		}
+		const required_attrs = gobj_check_required_attrs(gobj);
+		if (required_attrs) {
+			log_error(`${gobj_short_name(gobj)}: Cannot start without all required attributes: ` + JSON.stringify(required_attrs));
+			return -1;
+		}
 		if (__trace_gobj_start_stop__(gobj)) trace_machine(sprintf("⏺ ⏺ start: %s", gobj_full_name(gobj)));
 		gobj.running = true;
 		let ret = 0;
@@ -2353,7 +2383,7 @@
 			log_error(`gobj NULL, destroying, or bad type`);
 			return 0;
 		}
-		return rc_walk_by_list(gobj.dl_children, walk_type, cb_walking, user_data, user_data2);
+		return rc_walk_by_list(gobj, /* @__PURE__ */ new Set(), walk_type, cb_walking, user_data, user_data2);
 	}
 	/***************************************************************************
 	*
@@ -2363,7 +2393,7 @@
 			log_error(`gobj NULL, destroying, or bad type`);
 			return 0;
 		}
-		return rc_walk_by_tree(gobj.dl_children, walk_type, cb_walking, user_data, user_data2);
+		return rc_walk_by_tree(gobj, /* @__PURE__ */ new Set(), walk_type, cb_walking, user_data, user_data2);
 	}
 	/***************************************************************
 	*  Walking
@@ -2390,16 +2420,33 @@
 		log_error(`walk callback must return a NUMBER (-1 stop, 0 descend, >0 skip children), got ${typeof ret}: taken as 0`);
 		return 0;
 	}
-	function rc_walk_by_list(iter_, walk_type, cb_walking, user_data, user_data2) {
-		let iter = [...iter_];
+	/***************************************************************
+	*  Whether a walk steps over this gobj of the list of `owner`.
+	*
+	*  Each list is walked over a COPY of it, because a callback may destroy
+	*  any gobj of the list, the current one included, or move one with
+	*  gobj_change_parent(). One it destroyed is stepped over, as the C walk
+	*  does; one it moved is no longer in this list, and is handed where the
+	*  walk finds it now (7.26.27 handed it here AND there); and a gobj is
+	*  never handed twice in one walk (`seen`), wherever it was moved.
+	***************************************************************/
+	function walk_steps_over(child, owner, seen) {
+		return gobj_is_destroying(child) || child.parent !== owner || seen.has(child);
+	}
+	function rc_walk_by_list(owner, seen, walk_type, cb_walking, user_data, user_data2) {
+		let iter = [...owner.dl_children];
 		let child;
 		if (walk_type & walk_type_t.WALK_LAST2FIRST) for (let i = iter.length; i > 0; i--) {
 			child = iter[i - 1];
+			if (walk_steps_over(child, owner, seen)) continue;
+			seen.add(child);
 			let ret = walk_ret(cb_walking(child, user_data, user_data2));
 			if (ret < 0) return ret;
 		}
 		else for (let i = 0; i < iter.length; i++) {
 			child = iter[i];
+			if (walk_steps_over(child, owner, seen)) continue;
+			seen.add(child);
 			let ret = walk_ret(cb_walking(child, user_data, user_data2));
 			if (ret < 0) return ret;
 		}
@@ -2414,21 +2461,23 @@
 	*          or
 	*          WALK_LAST2FIRST
 	***************************************************************/
-	function rc_walk_by_level(iter, walk_type, cb_walking, user_data, user_data2) {
-		let ret = rc_walk_by_list(iter, walk_type, cb_walking, user_data, user_data2);
-		if (ret < 0) return ret;
-		let child;
-		if (walk_type & walk_type_t.WALK_LAST2FIRST) for (let i = iter.length; i > 0; i--) {
-			child = iter[i - 1];
-			ret = rc_walk_by_level([...child.dl_children], walk_type, cb_walking, user_data, user_data2);
+	function rc_walk_by_level(owner, seen, walk_type, cb_walking, user_data, user_data2) {
+		let iter = [...owner.dl_children];
+		if (walk_type & walk_type_t.WALK_LAST2FIRST) iter.reverse();
+		let handed = [];
+		for (const child of iter) {
+			if (walk_steps_over(child, owner, seen)) continue;
+			seen.add(child);
+			handed.push(child);
+			let ret = walk_ret(cb_walking(child, user_data, user_data2));
 			if (ret < 0) return ret;
 		}
-		else for (let i = 0; i < iter.length; i++) {
-			child = iter[i];
-			ret = rc_walk_by_level([...child.dl_children], walk_type, cb_walking, user_data, user_data2);
+		for (const child of handed) {
+			if (gobj_is_destroying(child)) continue;
+			let ret = rc_walk_by_level(child, seen, walk_type, cb_walking, user_data, user_data2);
 			if (ret < 0) return ret;
 		}
-		return ret;
+		return 0;
 	}
 	/***************************************************************
 	*  Walking
@@ -2445,23 +2494,29 @@
 	*          or
 	*          WALK_LAST2FIRST
 	***************************************************************/
-	function rc_walk_by_tree(iter, walk_type, cb_walking, user_data, user_data2) {
-		if (walk_type & walk_type_t.WALK_BYLEVEL) return rc_walk_by_level(iter, walk_type, cb_walking, user_data, user_data2);
+	function rc_walk_by_tree(owner, seen, walk_type, cb_walking, user_data, user_data2) {
+		if (walk_type & walk_type_t.WALK_BYLEVEL) return rc_walk_by_level(owner, seen, walk_type, cb_walking, user_data, user_data2);
+		let iter = [...owner.dl_children];
 		let ret;
 		let child;
 		if (walk_type & walk_type_t.WALK_BOTTOM2TOP) for (let i = iter.length; i > 0; i--) {
 			child = iter[i - 1];
-			ret = rc_walk_by_tree([...child.dl_children], walk_type, cb_walking, user_data, user_data2);
+			if (walk_steps_over(child, owner, seen)) continue;
+			ret = rc_walk_by_tree(child, seen, walk_type, cb_walking, user_data, user_data2);
 			if (ret < 0) return ret;
+			if (gobj_is_destroying(child)) continue;
+			seen.add(child);
 			ret = walk_ret(cb_walking(child, user_data, user_data2));
 			if (ret < 0) return ret;
 		}
 		else for (let i = 0; i < iter.length; i++) {
 			child = iter[i];
+			if (walk_steps_over(child, owner, seen)) continue;
+			seen.add(child);
 			ret = walk_ret(cb_walking(child, user_data, user_data2));
 			if (ret < 0) return ret;
-			else if (ret === 0) {
-				ret = rc_walk_by_tree([...child.dl_children], walk_type, cb_walking, user_data, user_data2);
+			else if (ret === 0 && !gobj_is_destroying(child)) {
+				ret = rc_walk_by_tree(child, seen, walk_type, cb_walking, user_data, user_data2);
 				if (ret < 0) return ret;
 			}
 		}
@@ -6046,44 +6101,99 @@
 		return kw_clone;
 	}
 	/********************************************
+	*  The browser's localStorage, or null when there is none (outside a
+	*  browser).
+	*
+	*  With the site's data blocked (Chrome with cookies blocked, a sandboxed
+	*  iframe), READING the window.localStorage property already throws a
+	*  SecurityError, not only its getItem(): every app reads its locale at
+	*  start, so the app did not start. Such a store is answered as one whose
+	*  every call throws that error, so each helper fails as it fails for any
+	*  store that refuses it: a read gives the default, a write -1.
+	********************************************/
+	function local_store() {
+		if (typeof window === "undefined") return null;
+		let store;
+		try {
+			store = window.localStorage;
+		} catch (e) {
+			const refuse = () => {
+				throw e;
+			};
+			return {
+				getItem: refuse,
+				setItem: refuse,
+				removeItem: refuse
+			};
+		}
+		return store || null;
+	}
+	/********************************************
+	*  A failure of the store that would repeat on every read is warned
+	*  once per key, until a read of the key goes well again.
+	********************************************/
+	var local_storage_warned = /* @__PURE__ */ new Set();
+	function warn_local_storage_once(key, msg) {
+		if (local_storage_warned.has(key)) return;
+		local_storage_warned.add(key);
+		log_warning(msg);
+	}
+	/********************************************
 	*  Get a local attribute
 	*
 	*  The json the entry holds, or `default_value` when there is none
 	*  (written there too with `create`). A json null is no value, as
 	*  json_absent() in C: the default. An entry that is not json (a
-	*  corrupt or foreign write) is one WARNING and is REMOVED, so the
+	*  corrupt or foreign write) is a WARNING and is REMOVED, so the
 	*  next read finds no entry: it used to console.warn on every read,
-	*  for ever. Its text is never shown (JSON.parse() quotes it in its
-	*  error, and an entry can hold a token). A store that cannot be read
-	*  is warned once per key. Outside a browser: the default.
+	*  for ever; a new corrupt entry is a new WARNING. Its text is never
+	*  shown (JSON.parse() quotes it in its error, and an entry can hold a
+	*  token). A store that cannot be read (blocked) is warned once per
+	*  key, and the default is NOT written there; one that cannot be
+	*  written (full) is warned once per key too: with `create` it was an
+	*  ERROR on every read, the default tried again each time. A key is
+	*  warned again after a read that goes well. Outside a browser: the
+	*  default.
 	********************************************/
-	var local_storage_warned = /* @__PURE__ */ new Set();
-	function warn_local_storage_once(key, what) {
-		if (local_storage_warned.has(key)) return;
-		local_storage_warned.add(key);
-		log_warning(`kw_get_local_storage_value(): localStorage key "${key}" ${what}`);
-	}
 	function kw_get_local_storage_value(key, default_value, create = false) {
-		if (typeof window === "undefined" || !window.localStorage) return default_value;
+		const store = local_store();
+		if (!store) return default_value;
+		const where = `kw_get_local_storage_value(): localStorage key "${key}"`;
 		let text;
 		try {
-			text = window.localStorage.getItem(key);
+			text = store.getItem(key);
 		} catch (e) {
-			warn_local_storage_once(key, "cannot be read (storage blocked?): the default is used");
+			warn_local_storage_once(key, `${where} cannot be read (storage blocked?): the default is used`);
 			return default_value;
 		}
+		let went_well = true;
 		let value = null;
 		if (text !== null) try {
 			value = JSON.parse(text);
 		} catch (e) {
-			warn_local_storage_once(key, "does not hold json: removed, the default is used");
-			kw_remove_local_storage_value(key);
 			value = null;
+			try {
+				store.removeItem(key);
+				log_warning(`${where} does not hold json: removed, the default is used`);
+			} catch (e2) {
+				went_well = false;
+				warn_local_storage_once(key, `${where} does not hold json and cannot be removed: the default is used`);
+			}
 		}
 		if (value === null) {
-			if (create) kw_set_local_storage_value(key, default_value);
-			return default_value;
+			value = default_value;
+			if (create) {
+				const default_text = json_text_of(default_value);
+				if (default_text === void 0) log_error(`${where}: cannot write the default: a value with no json text`);
+				else try {
+					store.setItem(key, default_text);
+				} catch (e) {
+					went_well = false;
+					warn_local_storage_once(key, `${where} cannot be written (storage full or blocked?): the default is used, not kept`);
+				}
+			}
 		}
+		if (went_well) local_storage_warned.delete(key);
 		return value;
 	}
 	/********************************************
@@ -6095,15 +6205,26 @@
 	*  reported success on a store that had rejected the write: a full or blocked
 	*  localStorage (quota, private mode) silently discarded the change while the
 	*  UI showed it as saved.
+	*
+	*  A value with no json text is refused with an ERROR, as a typed writer
+	*  refuses it (json_text_of()): a function was stored as the text
+	*  "undefined", and a NaN, a Date or a Map as a text that reads back as
+	*  another value. Checked in Node.js too, where there is no store.
 	********************************************/
 	function kw_set_local_storage_value(key, value) {
-		if (typeof window === "undefined" || !window.localStorage) return 0;
-		if (!key || value === void 0) {
-			log_error(`kw_set_local_storage_value(): invalid key or value: key=${key}`);
+		if (!key) {
+			log_error(`kw_set_local_storage_value(): invalid key: key=${key}`);
+			return -1;
+		}
+		const text = json_text_of(value);
+		if (text === void 0) {
+			log_error(`kw_set_local_storage_value(): cannot save "${key}": a value with no json text`);
 			return -1;
 		}
+		const store = local_store();
+		if (!store) return 0;
 		try {
-			window.localStorage.setItem(key, JSON.stringify(value));
+			store.setItem(key, text);
 			return 0;
 		} catch (e) {
 			log_error(`kw_set_local_storage_value(): cannot save "${key}" (storage full or blocked?): ${e && e.message ? e.message : e}`);
@@ -6114,15 +6235,16 @@
 	*  Remove local attribute
 	********************************************/
 	function kw_remove_local_storage_value(key) {
-		if (typeof window === "undefined" || !window.localStorage) return;
+		const store = local_store();
+		if (!store) return;
 		if (!key) {
-			window.console.warn(`Invalid key for localStorage removal: ${key}`);
+			log_error(`kw_remove_local_storage_value(): invalid key: key=${key}`);
 			return;
 		}
 		try {
-			window.localStorage.removeItem(key);
+			store.removeItem(key);
 		} catch (e) {
-			window.console.warn(`Error removing localStorage key "${key}":`, e);
+			log_warning(`kw_remove_local_storage_value(): cannot remove "${key}" (storage blocked?): ${e && e.message ? e.message : e}`);
 		}
 	}
 	/*************************************************************
@@ -7311,19 +7433,62 @@
 		return -1;
 	}
 	/************************************************************
+	*  A new uuid v4 (RFC 9562).
 	*
+	*  crypto.randomUUID() exists only in a secure context, so a page
+	*  served over http without TLS has none; crypto.getRandomValues()
+	*  exists there too. With no crypto at all, Math.random(): not fit
+	*  for a secret, and a uuid that names a node is not one.
 	************************************************************/
+	function new_uuid() {
+		const c = typeof window !== "undefined" && window.crypto || globalThis.crypto;
+		if (c && typeof c.randomUUID === "function") return c.randomUUID();
+		const b = /* @__PURE__ */ new Uint8Array(16);
+		if (c && typeof c.getRandomValues === "function") c.getRandomValues(b);
+		else for (let i = 0; i < b.length; i++) b[i] = Math.floor(Math.random() * 256);
+		b[6] = b[6] & 15 | 64;
+		b[8] = b[8] & 63 | 128;
+		const h = Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+		return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+	}
+	/************************************************************
+	*  The uuid of this node: ONE for the life of the page.
+	*
+	*  The one the store keeps ("host_uuid"), made and written there when
+	*  there is none. When the store cannot keep it (blocked, full, no
+	*  localStorage, outside a browser) the one this page made, warned
+	*  once. It goes in the node_uuid attribute of the yuno, the id of the
+	*  identity card and the `host` of every message the client sends, so
+	*  the first answer is kept and answered again: 7.26.27 made a new
+	*  uuid on every call when the store could not keep it, and answered
+	*  null without crypto.randomUUID().
+	************************************************************/
+	var uuid_of_this_page = null;
 	function node_uuid() {
-		let uuid = "";
-		if (typeof window !== "undefined" && window.localStorage) {
-			uuid = window.localStorage.getItem("host_uuid");
-			if (!uuid && window.crypto?.randomUUID) {
-				uuid = window.crypto.randomUUID();
-				window.localStorage.setItem("host_uuid", uuid);
+		if (uuid_of_this_page) return uuid_of_this_page;
+		const store = local_store();
+		if (!store) {
+			uuid_of_this_page = new_uuid();
+			return uuid_of_this_page;
+		}
+		let uuid = null;
+		try {
+			uuid = store.getItem("host_uuid");
+		} catch (e) {
+			warn_local_storage_once("host_uuid", "node_uuid(): localStorage cannot be read (storage blocked?): a uuid of this page only");
+			uuid_of_this_page = new_uuid();
+			return uuid_of_this_page;
+		}
+		if (!uuid) {
+			uuid = new_uuid();
+			try {
+				store.setItem("host_uuid", uuid);
+			} catch (e) {
+				warn_local_storage_once("host_uuid", "node_uuid(): localStorage cannot be written (storage full or blocked?): a uuid of this page only");
 			}
-		} else if (typeof globalThis !== "undefined" && globalThis.crypto?.randomUUID) uuid = globalThis.crypto.randomUUID();
-		else uuid = "00000000-0000-0000-0000-000000000000";
-		return uuid;
+		}
+		uuid_of_this_page = uuid;
+		return uuid_of_this_page;
 	}
 	/************************************************************
 	*   Build a cleaned name
@@ -8608,7 +8773,7 @@
 		SDATA(data_type_t.DTP_STRING, "cert_pem", sdata_flag_t.SDF_PERSIST, "", "SSL server certification, PEM str format"),
 		SDATA(data_type_t.DTP_JSON, "extra_info", sdata_flag_t.SDF_RD, "{}", "dict data set by user, added to the identity card msg."),
 		SDATA(data_type_t.DTP_LIST, "required_services", sdata_flag_t.SDF_RD, "[]", "Services this LINK requires (identity card). Empty = the yuno's `required_services`, as before. A yuno with several links to DIFFERENT backends must set it per link: the yuno-wide list is the union, so every backend is told the service names of all the others."),
-		SDATA(data_type_t.DTP_INTEGER, "timeout_retry", sdata_flag_t.SDF_RD, "5000", "First reconnect delay (ms). It BACKS OFF from here, doubling up to timeout_retry_max, and resets when a session is reached"),
+		SDATA(data_type_t.DTP_INTEGER, "timeout_retry", sdata_flag_t.SDF_RD, "5000", "Base of the first reconnect delay (ms, ±20% jitter), at least 1000. It BACKS OFF from here, doubling up to timeout_retry_max, and resets when a session is reached"),
 		SDATA(data_type_t.DTP_INTEGER, "timeout_retry_max", sdata_flag_t.SDF_RD, "60000", "Cap of the reconnect backoff (ms). Set it equal to timeout_retry for the old fixed-interval behaviour"),
 		SDATA(data_type_t.DTP_INTEGER, "timeout_idack", sdata_flag_t.SDF_RD, "5000", "timeout waiting idAck"),
 		SDATA(data_type_t.DTP_POINTER, "subscriber", 0, 0, "subscriber of output-events. If null then subscriber is the parent"),
@@ -8633,7 +8798,8 @@
 		inside_on_open: false,
 		retry_ms: 0,
 		retry_ms_before_session: 0,
-		session_since: 0
+		session_since: 0,
+		retry_floor_warned: false
 	};
 	var __gclass__ = null;
 	/******************************
@@ -8905,7 +9071,7 @@
 	function close_for_peer_fault(gobj, reason) {
 		let priv = gobj.priv;
 		if (gobj_current_state(gobj) === "ST_SESSION") {
-			if (performance.now() - priv.session_since < Math.max(gobj_read_integer_attr(gobj, "timeout_retry"), gobj_read_integer_attr(gobj, "timeout_retry_max"))) priv.retry_ms = priv.retry_ms_before_session;
+			if (performance.now() - priv.session_since < retry_bounds(gobj).max) priv.retry_ms = priv.retry_ms_before_session;
 			priv.retry_ms_before_session = 0;
 		}
 		close_websocket(gobj, CLOSE_PEER_FAULT, reason);
@@ -9177,6 +9343,32 @@
 		return 0;
 	}
 	/***************************************************************
+	*  The first delay of the backoff and its cap.
+	*
+	*  A first delay below RETRY_FLOOR_MS is raised to it, with a WARNING
+	*  once: `timeout_retry` 0 never left 0 (0 doubled is 0), so a server
+	*  that closed before the ack was reconnected in a loop with no wait,
+	*  hundreds of connections a second.
+	***************************************************************/
+	var RETRY_FLOOR_MS = 1e3;
+	function retry_bounds(gobj) {
+		let priv = gobj.priv;
+		let base = gobj_read_integer_attr(gobj, "timeout_retry");
+		let max = gobj_read_integer_attr(gobj, "timeout_retry_max");
+		if (!(base >= RETRY_FLOOR_MS)) {
+			if (!priv.retry_floor_warned) {
+				priv.retry_floor_warned = true;
+				log_warning(`${gobj_short_name(gobj)}: timeout_retry ${base} ms is below ${RETRY_FLOOR_MS} ms: ${RETRY_FLOOR_MS} ms is used`);
+			}
+			base = RETRY_FLOOR_MS;
+		}
+		if (!(max >= base)) max = base;
+		return {
+			base,
+			max
+		};
+	}
+	/***************************************************************
 	*  How long to wait before the next reconnect attempt.
 	*
 	*  The delay used to be a constant (`timeout_retry`, 5s), for ever. A
@@ -9197,9 +9389,7 @@
 	***************************************************************/
 	function next_retry(gobj) {
 		let priv = gobj.priv;
-		let base = gobj_read_integer_attr(gobj, "timeout_retry");
-		let max = gobj_read_integer_attr(gobj, "timeout_retry_max");
-		if (max < base) max = base;
+		const { base, max } = retry_bounds(gobj);
 		priv.retry_ms = priv.retry_ms ? Math.min(priv.retry_ms * 2, max) : base;
 		let jitter = priv.retry_ms * .2;
 		let ms = priv.retry_ms - jitter + Math.random() * 2 * jitter;
@@ -9697,6 +9887,7 @@
 	exports.json_object_update_existing = json_object_update_existing;
 	exports.json_object_update_missing = json_object_update_missing;
 	exports.json_size = json_size;
+	exports.json_text_of = json_text_of;
 	exports.jwt2json = jwt2json;
 	exports.jwtDecode = jwtDecode;
 	exports.kw_clone_by_keys = kw_clone_by_keys;