amule-ec-client 0.6.0 → 0.7.0

package/dist/UpdateState-Dn-SuAsj.js

@@ -0,0 +1,173 @@
+import { f as findNumericTag, p as findTag } from "./Tag-B5gWV2XF.js";
+import { a as toOptionalNumber, i as toOptionalIp, n as tagOwnNumericValue, r as toOptionalBool } from "./utils-CNoUroOI.js";
+import { a as rleDecode, i as extractPartFileStatusBuffers, o as sourceNameEntriesFromFileTag, r as computeChunkInfo, s as xorReconstruct, t as DownloadQueueResponseParser } from "./DownloadQueueResponse-C-5d4teB.js";
+import { t as SharedFilesResponseParser } from "./SharedFilesResponse-DE0cd1DT.js";
+import { t as ClientQueueResponseParser } from "./ClientQueueResponse-CXxY_9wU.js";
+import { t as ServerListResponseParser } from "./ServerListResponse-Do3iRai0.js";
+//#region src/response/UpdateResponse.ts
+var UpdateResponseParser = class {
+	static fromPacket(packet) {
+		const sharedFiles = SharedFilesResponseParser.fromPacket(packet).files;
+		const downloadQueue = DownloadQueueResponseParser.fromPacket(packet).files;
+		const clientContainer = findTag(packet.tags, 1536);
+		const clients = clientContainer && clientContainer.nestedTags ? ClientQueueResponseParser.fromTags(clientContainer.nestedTags).clients : [];
+		const serverContainer = findTag(packet.tags, 1280);
+		const servers = serverContainer && serverContainer.nestedTags ? ServerListResponseParser.fromTags(serverContainer.nestedTags).servers : [];
+		const friendContainer = findTag(packet.tags, 2048);
+		return {
+			sharedFiles,
+			downloadQueue,
+			clients,
+			servers,
+			friends: friendContainer && friendContainer.nestedTags ? this.parseFriends(friendContainer.nestedTags) : []
+		};
+	}
+	static parseFriends(tags) {
+		const friends = [];
+		const friendTags = tags.filter((t) => t.name === 2048);
+		for (const friendTag of friendTags) {
+			const nested = friendTag.nestedTags || [];
+			friends.push({
+				name: findTag(nested, 2049)?.getValue(),
+				userHashHexString: findTag(nested, 2050)?.getValue()?.toString("hex"),
+				ip: toOptionalIp(findNumericTag(nested, 2051)?.getInt()),
+				port: findNumericTag(nested, 2052)?.getInt(),
+				friendSlot: toOptionalBool(findNumericTag(nested, 2056)?.getInt()),
+				shared: toOptionalBool(findNumericTag(nested, 2057)?.getInt()),
+				client: ClientQueueResponseParser.fromTags(nested).clients[0]
+			});
+		}
+		return friends;
+	}
+};
+//#endregion
+//#region src/client/UpdateState.ts
+const STATUS_BUFFER_KEYS = [
+	"partStatus",
+	"gapStatus",
+	"reqStatus"
+];
+/**
+* Merge update fields into the existing object. Fields absent from an incremental
+* response are undefined after parsing and must not clobber previously known values.
+*/
+function mergeDefined(existing, updates) {
+	const result = { ...existing };
+	for (const [key, value] of Object.entries(updates)) if (value !== void 0) result[key] = value;
+	return result;
+}
+var UpdateState = class {
+	sessionGeneration;
+	downloads = /* @__PURE__ */ new Map();
+	sharedFiles = /* @__PURE__ */ new Map();
+	clients = /* @__PURE__ */ new Map();
+	statusBuffers = /* @__PURE__ */ new Map();
+	sourceNames = /* @__PURE__ */ new Map();
+	/**
+	* @param sessionGeneration Connection generation this state belongs to (see
+	* AmuleConnection.getSessionGeneration). The state is only valid while the
+	* connection that produced it is alive, since the daemon diffs per connection.
+	*/
+	constructor(sessionGeneration) {
+		this.sessionGeneration = sessionGeneration;
+	}
+	apply(packet) {
+		const parsed = UpdateResponseParser.fromPacket(packet);
+		for (const file of parsed.downloadQueue) {
+			delete file.chunkInfo;
+			delete file.sourceNames;
+		}
+		const downloadQueue = this.mergeCollection(this.downloads, parsed.downloadQueue);
+		const sharedFiles = this.mergeCollection(this.sharedFiles, parsed.sharedFiles);
+		const clients = this.mergeCollection(this.clients, parsed.clients);
+		for (const ecid of [...this.statusBuffers.keys()]) if (!this.downloads.has(ecid)) this.statusBuffers.delete(ecid);
+		for (const ecid of [...this.sourceNames.keys()]) if (!this.downloads.has(ecid)) this.sourceNames.delete(ecid);
+		this.reconstructFileDetails(packet);
+		this.attachSources();
+		return {
+			downloadQueue,
+			sharedFiles,
+			clients,
+			servers: parsed.servers,
+			friends: parsed.friends
+		};
+	}
+	mergeCollection(state, items) {
+		const seen = /* @__PURE__ */ new Set();
+		const result = [];
+		for (const item of items) {
+			if (item.ecid === void 0) {
+				result.push(item);
+				continue;
+			}
+			seen.add(item.ecid);
+			const existing = state.get(item.ecid);
+			const merged = existing ? mergeDefined(existing, item) : item;
+			state.set(item.ecid, merged);
+			result.push(merged);
+		}
+		for (const ecid of [...state.keys()]) if (!seen.has(ecid)) state.delete(ecid);
+		return result;
+	}
+	/**
+	* Reconstruct the incremental per-file details of each partfile in the packet:
+	* RLE-decode and XOR-reconstruct the status buffers (recomputing chunk info from the
+	* accumulated state), and apply the source-names map diffs (new entry / count change /
+	* removal when count is 0).
+	*/
+	reconstructFileDetails(packet) {
+		const partfileTags = packet.tags.filter((tag) => tag.name === 768);
+		for (const fileTag of partfileTags) {
+			const ecid = tagOwnNumericValue(fileTag);
+			if (ecid === void 0) continue;
+			const file = this.downloads.get(ecid);
+			if (!file) continue;
+			const raw = extractPartFileStatusBuffers(fileTag);
+			const state = this.statusBuffers.get(ecid) || {};
+			for (const key of STATUS_BUFFER_KEYS) {
+				const rawBuffer = raw[key];
+				if (!rawBuffer || rawBuffer.length === 0) continue;
+				const decoded = rleDecode(rawBuffer);
+				const previous = state[key];
+				state[key] = previous ? xorReconstruct(previous, decoded) : decoded;
+			}
+			this.statusBuffers.set(ecid, state);
+			if (file.sizeFull && file.sizeFull > 0) file.chunkInfo = computeChunkInfo(file.sizeFull, state);
+			const entries = sourceNameEntriesFromFileTag(fileTag);
+			if (entries) {
+				const nameMap = this.sourceNames.get(ecid) || /* @__PURE__ */ new Map();
+				for (const entry of entries) {
+					if (entry.count === 0) {
+						nameMap.delete(entry.id);
+						continue;
+					}
+					const existing = nameMap.get(entry.id);
+					if (existing) {
+						existing.count = entry.count;
+						if (entry.name !== void 0) existing.name = entry.name;
+					} else if (entry.name !== void 0) nameMap.set(entry.id, {
+						name: entry.name,
+						count: entry.count
+					});
+				}
+				this.sourceNames.set(ecid, nameMap);
+			}
+			const nameMap = this.sourceNames.get(ecid);
+			if (nameMap) file.sourceNames = [...nameMap.values()];
+		}
+	}
+	/**
+	* Group clients by the download they are requesting (client.requestFileId -> file.ecid).
+	*/
+	attachSources() {
+		for (const file of this.downloads.values()) file.sources = [];
+		for (const client of this.clients.values()) {
+			const requestFileId = toOptionalNumber(client.requestFileId);
+			if (requestFileId === void 0) continue;
+			const file = this.downloads.get(requestFileId);
+			if (file) file.sources.push(client);
+		}
+	}
+};
+//#endregion
+export { UpdateState };

package/dist/{download-details-OM0FJUhZ.mjs → download-details-OM0FJUhZ.js}

@@ -8,5 +8,3 @@ const ChunkStatus = {
 };
 //#endregion
 export { PARTSIZE as n, ChunkStatus as t };
-
-//# sourceMappingURL=download-details-OM0FJUhZ.mjs.map