@abraca/dabra 2.7.0 → 2.9.0

package/dist/abracadabra-provider.cjs

@@ -1233,6 +1233,8 @@ var AbracadabraWS = class extends EventEmitter {
 		this.identifier = 0;
 		this.intervals = { connectionChecker: null };
 		this.connectionAttempt = null;
+		this.onlineListener = null;
+		this.offlineListener = null;
 		this.receivedOnOpenPayload = void 0;
 		this.closeTries = 0;
 		this.setConfiguration(configuration);
@@ -1251,8 +1253,39 @@ var AbracadabraWS = class extends EventEmitter {
 		this.on("close", this.onClose.bind(this));
 		this.on("message", this.onMessage.bind(this));
 		this.intervals.connectionChecker = setInterval(this.checkConnection.bind(this), this.configuration.messageReconnectTimeout / 10);
+		if (typeof window !== "undefined" && typeof window.addEventListener === "function") {
+			this.onlineListener = this.handleOnline.bind(this);
+			this.offlineListener = this.handleOffline.bind(this);
+			window.addEventListener("online", this.onlineListener);
+			window.addEventListener("offline", this.offlineListener);
+		}
 		if (this.shouldConnect) this.connect();
 	}
+	/**
+	* Whether the device currently believes it has network connectivity.
+	*
+	* Treats "unknown" as online: in Node and other non-browser environments
+	* `navigator` (or `navigator.onLine`) is absent, and we must not gate
+	* reconnection there — only the browser exposes a trustworthy signal.
+	*/
+	get isOnline() {
+		return typeof navigator === "undefined" || navigator.onLine !== false;
+	}
+	handleOnline() {
+		if (this.shouldConnect && this.status !== WebSocketStatus.Connected) this.connect();
+	}
+	handleOffline() {
+		if (this.cancelWebsocketRetry) {
+			this.cancelWebsocketRetry();
+			this.cancelWebsocketRetry = void 0;
+		}
+		try {
+			this.webSocket?.close();
+			this.messageQueue = [];
+		} catch (e) {
+			console.error(e);
+		}
+	}
 	async onOpen(event) {
 		this.status = WebSocketStatus.Connected;
 		this.emit("status", { status: WebSocketStatus.Connected });
@@ -1282,6 +1315,10 @@ var AbracadabraWS = class extends EventEmitter {
 	}
 	async connect() {
 		if (this.status === WebSocketStatus.Connected) return;
+		if (!this.isOnline) {
+			this.shouldConnect = true;
+			return;
+		}
 		if (this.cancelWebsocketRetry) {
 			this.cancelWebsocketRetry();
 			this.cancelWebsocketRetry = void 0;
@@ -1446,7 +1483,7 @@ var AbracadabraWS = class extends EventEmitter {
 		const isRateLimited = event?.code === 4429 || event === 4429;
 		this.emit("disconnect", { event });
 		if (isRateLimited) this.emit("rateLimited");
-		if (!this.cancelWebsocketRetry && this.shouldConnect) {
+		if (!this.cancelWebsocketRetry && this.shouldConnect && this.isOnline) {
 			const delay = isRateLimited ? 6e4 : this.configuration.delay;
 			setTimeout(() => {
 				this.connect();
@@ -1456,6 +1493,12 @@ var AbracadabraWS = class extends EventEmitter {
 	destroy() {
 		this.shouldConnect = false;
 		this.emit("destroy");
+		if (typeof window !== "undefined" && typeof window.removeEventListener === "function") {
+			if (this.onlineListener) window.removeEventListener("online", this.onlineListener);
+			if (this.offlineListener) window.removeEventListener("offline", this.offlineListener);
+		}
+		this.onlineListener = null;
+		this.offlineListener = null;
 		clearInterval(this.intervals.connectionChecker);
 		this.stopConnectionAttempt();
 		this.disconnect();
@@ -15715,6 +15758,19 @@ function makeEntryMap(fields) {
 	return m;
 }
 /**
+* A label is a "placeholder" — i.e. carries no real user title — when it is
+* empty/whitespace, null/undefined, or the literal `"Untitled"` sentinel
+* (case-insensitive, so `"untitled"` from a `labelToFilename` round-trip is
+* caught too). The whole tree-label corruption class boils down to a
+* placeholder being allowed to overwrite a real title; `patchEntry` refuses
+* exactly that. Mirrors cou-sh's `isEmptyTreeLabel`.
+*/
+function isPlaceholderLabel(label) {
+	if (typeof label !== "string") return label == null;
+	const t = label.trim();
+	return t === "" || t.toLowerCase() === "untitled";
+}
+/**
 * Patch an EXISTING entry's fields per-key on its nested `Y.Map`, so a
 * concurrent edit to a *different* field by a peer is preserved instead
 * of being clobbered by a whole-entry write — the whole-entry-LWW fix
@@ -15729,21 +15785,44 @@ function makeEntryMap(fields) {
 * Self-transacting: it batches its writes in one `Y.Doc` transaction
 * (a safe reentrant no-op join when already inside one), so callers
 * don't need to pass or own a transaction.
+*
+* ── NO-DESTROY LABEL INVARIANT ──────────────────────────────────────────
+* A `label` patch that is a placeholder (empty/whitespace/"Untitled") is
+* DROPPED when the entry already holds a real (non-placeholder) label —
+* regardless of which consumer (cou-sh title-sync, fs-sync rename
+* detection, MCP, table renderers, a stale snapshot) tried it. This is the
+* source-of-truth guard against the "card title silently becomes Untitled
+* / files renamed to untitled.md" corruption: a placeholder must never win
+* over a real title. Creating a brand-new entry with an empty label (e.g.
+* a fresh kanban card) is still allowed — the guard only fires when a real
+* label already exists. Pass `{ allowLabelClear: true }` to override (the
+* single legitimate "user explicitly cleared it" path).
 */
-function patchEntry(treeMap, id, patch, removeKeys = []) {
+function patchEntry(treeMap, id, patch, removeKeys = [], opts = {}) {
 	const apply = () => {
 		const raw = treeMap.get(id);
+		let effectivePatch = patch;
+		if (!opts.allowLabelClear && Object.hasOwn(patch, "label") && isPlaceholderLabel(patch.label)) {
+			let existingLabel;
+			if (raw != null && typeof raw.get === "function") existingLabel = raw.get("label");
+			else if (raw != null && typeof raw.toJSON === "function") existingLabel = raw.toJSON()?.label;
+			else if (raw != null && typeof raw === "object") existingLabel = raw.label;
+			if (!isPlaceholderLabel(existingLabel)) {
+				const { label: _dropped, ...rest } = patch;
+				effectivePatch = rest;
+			}
+		}
 		if (raw instanceof yjs.Map) {
-			for (const [k, v] of Object.entries(patch)) if (v === void 0) raw.delete(k);
+			for (const [k, v] of Object.entries(effectivePatch)) if (v === void 0) raw.delete(k);
 			else raw.set(k, v);
 			for (const k of removeKeys) raw.delete(k);
 			return;
 		}
 		const merged = {
 			...raw == null ? {} : toPlain(raw),
-			...patch
+			...effectivePatch
 		};
-		for (const [k, v] of Object.entries(patch)) if (v === void 0) delete merged[k];
+		for (const [k, v] of Object.entries(effectivePatch)) if (v === void 0) delete merged[k];
 		for (const k of removeKeys) delete merged[k];
 		treeMap.set(id, makeEntryMap(merged));
 	};
@@ -20900,6 +20979,7 @@ exports.filenameToLabel = filenameToLabel;
 exports.foldRecords = foldRecords;
 exports.generateMnemonic = generateMnemonic;
 exports.isEncryptedContent = isEncryptedContent;
+exports.isPlaceholderLabel = isPlaceholderLabel;
 exports.makeEncryptedYMap = makeEncryptedYMap;
 exports.makeEncryptedYText = makeEncryptedYText;
 exports.makeEntryMap = makeEntryMap;