@envive-ai/react-hooks 0.2.10-arthur-3 → 0.2.11

package/dist/application/utils/coreUserEventToApiUserEvent.js

@@ -0,0 +1,73 @@
+import { PLPAttributeCategory, UserEventCategory } from "@spiffy-ai/commerce-api-client";
+
+//#region src/application/utils/coreUserEventToApiUserEvent.ts
+const coreUserEventToApiUserEvent = (data) => {
+	if (data.category === UserEventCategory.PdpVisit || data.category === UserEventCategory.AddToCart) return {
+		event_id: data.eventId,
+		created_at: data.createdAt,
+		category: data.category,
+		attributes: {
+			product_id: data.attributes.productId,
+			parent_product_id: data.attributes.parentProductId,
+			url: data.attributes.url
+		}
+	};
+	if (data.category === UserEventCategory.PlpVisit) return {
+		event_id: data.eventId,
+		created_at: data.createdAt,
+		category: data.category,
+		attributes: {
+			category: PLPAttributeCategory.Id,
+			attributes: { id: data.attributes.attributes.id }
+		}
+	};
+	if (data.category === UserEventCategory.QueryTyped) return {
+		event_id: data.eventId,
+		created_at: data.createdAt,
+		category: data.category,
+		attributes: { query: data.attributes.query }
+	};
+	if (data.category === UserEventCategory.Search) return {
+		event_id: data.eventId,
+		created_at: data.createdAt,
+		category: data.category,
+		attributes: {
+			search_term: data.attributes.searchTerm,
+			selected_filters: data.attributes.selectedFilters
+		}
+	};
+	if (data.category === UserEventCategory.SuggestionClicked) return {
+		event_id: data.eventId,
+		created_at: data.createdAt,
+		category: data.category,
+		attributes: { suggestion_id: data.attributes.suggestionId }
+	};
+	if (data.category === UserEventCategory.PageVisit) return {
+		event_id: data.eventId,
+		created_at: data.createdAt,
+		category: data.category,
+		attributes: {
+			url: data.attributes.url,
+			page_visit_category: data.attributes.pageVisitCategory
+		}
+	};
+	if (data.category === UserEventCategory.FormSubmitted) return {
+		event_id: data.eventId,
+		created_at: data.createdAt,
+		category: data.category,
+		attributes: {
+			filled_schema: { ...data.attributes.filledSchema },
+			form_response_id: data.attributes.formResponseId,
+			form_type: data.attributes.formType
+		}
+	};
+	return {
+		event_id: data.eventId,
+		created_at: data.createdAt,
+		category: data.category
+	};
+};
+
+//#endregion
+export { coreUserEventToApiUserEvent };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29yZVVzZXJFdmVudFRvQXBpVXNlckV2ZW50LmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hcHBsaWNhdGlvbi91dGlscy9jb3JlVXNlckV2ZW50VG9BcGlVc2VyRXZlbnQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgVXNlckV2ZW50IGFzIEFwaVVzZXJFdmVudCxcbiAgUExQQXR0cmlidXRlQ2F0ZWdvcnksXG4gIFBMUElkQXR0cmlidXRlcyxcbiAgVXNlckV2ZW50Q2F0ZWdvcnksXG59IGZyb20gJ0BzcGlmZnktYWkvY29tbWVyY2UtYXBpLWNsaWVudCc7XG5pbXBvcnQgeyBVc2VyRXZlbnQgYXMgQ29yZVVzZXJFdmVudCB9IGZyb20gJy4uL21vZGVscyc7XG5cbmV4cG9ydCBjb25zdCBjb3JlVXNlckV2ZW50VG9BcGlVc2VyRXZlbnQgPSAoZGF0YTogQ29yZVVzZXJFdmVudCk6IEFwaVVzZXJFdmVudCA9PiB7XG4gIGlmIChcbiAgICBkYXRhLmNhdGVnb3J5ID09PSBVc2VyRXZlbnRDYXRlZ29yeS5QZHBWaXNpdCB8fFxuICAgIGRhdGEuY2F0ZWdvcnkgPT09IFVzZXJFdmVudENhdGVnb3J5LkFkZFRvQ2FydFxuICApIHtcbiAgICByZXR1cm4ge1xuICAgICAgZXZlbnRfaWQ6IGRhdGEuZXZlbnRJZCxcbiAgICAgIGNyZWF0ZWRfYXQ6IGRhdGEuY3JlYXRlZEF0LFxuICAgICAgY2F0ZWdvcnk6IGRhdGEuY2F0ZWdvcnksXG4gICAgICBhdHRyaWJ1dGVzOiB7XG4gICAgICAgIHByb2R1Y3RfaWQ6IGRhdGEuYXR0cmlidXRlcy5wcm9kdWN0SWQsXG4gICAgICAgIHBhcmVudF9wcm9kdWN0X2lkOiBkYXRhLmF0dHJpYnV0ZXMucGFyZW50UHJvZHVjdElkLFxuICAgICAgICB1cmw6IGRhdGEuYXR0cmlidXRlcy51cmwsXG4gICAgICB9LFxuICAgIH07XG4gIH1cblxuICBpZiAoZGF0YS5jYXRlZ29yeSA9PT0gVXNlckV2ZW50Q2F0ZWdvcnkuUGxwVmlzaXQpIHtcbiAgICByZXR1cm4ge1xuICAgICAgZXZlbnRfaWQ6IGRhdGEuZXZlbnRJZCxcbiAgICAgIGNyZWF0ZWRfYXQ6IGRhdGEuY3JlYXRlZEF0LFxuICAgICAgY2F0ZWdvcnk6IGRhdGEuY2F0ZWdvcnksXG4gICAgICBhdHRyaWJ1dGVzOiB7XG4gICAgICAgIGNhdGVnb3J5OiBQTFBBdHRyaWJ1dGVDYXRlZ29yeS5JZCxcbiAgICAgICAgYXR0cmlidXRlczoge1xuICAgICAgICAgIC8vIHdlJ3JlIG9ubHkgaGFuZGxpbmcgaWQgYXR0cmlidXRlcyBmb3Igbm93XG4gICAgICAgICAgaWQ6IChkYXRhLmF0dHJpYnV0ZXMuYXR0cmlidXRlcyBhcyBQTFBJZEF0dHJpYnV0ZXMpLmlkLFxuICAgICAgICB9LFxuICAgICAgfSxcbiAgICB9O1xuICB9XG5cbiAgaWYgKGRhdGEuY2F0ZWdvcnkgPT09IFVzZXJFdmVudENhdGVnb3J5LlF1ZXJ5VHlwZWQpIHtcbiAgICByZXR1cm4ge1xuICAgICAgZXZlbnRfaWQ6IGRhdGEuZXZlbnRJZCxcbiAgICAgIGNyZWF0ZWRfYXQ6IGRhdGEuY3JlYXRlZEF0LFxuICAgICAgY2F0ZWdvcnk6IGRhdGEuY2F0ZWdvcnksXG4gICAgICBhdHRyaWJ1dGVzOiB7XG4gICAgICAgIHF1ZXJ5OiBkYXRhLmF0dHJpYnV0ZXMucXVlcnksXG4gICAgICB9LFxuICAgIH07XG4gIH1cblxuICBpZiAoZGF0YS5jYXRlZ29yeSA9PT0gVXNlckV2ZW50Q2F0ZWdvcnkuU2VhcmNoKSB7XG4gICAgcmV0dXJuIHtcbiAgICAgIGV2ZW50X2lkOiBkYXRhLmV2ZW50SWQsXG4gICAgICBjcmVhdGVkX2F0OiBkYXRhLmNyZWF0ZWRBdCxcbiAgICAgIGNhdGVnb3J5OiBkYXRhLmNhdGVnb3J5LFxuICAgICAgYXR0cmlidXRlczoge1xuICAgICAgICBzZWFyY2hfdGVybTogZGF0YS5hdHRyaWJ1dGVzLnNlYXJjaFRlcm0sXG4gICAgICAgIHNlbGVjdGVkX2ZpbHRlcnM6IGRhdGEuYXR0cmlidXRlcy5zZWxlY3RlZEZpbHRlcnMsXG4gICAgICB9LFxuICAgIH07XG4gIH1cblxuICBpZiAoZGF0YS5jYXRlZ29yeSA9PT0gVXNlckV2ZW50Q2F0ZWdvcnkuU3VnZ2VzdGlvbkNsaWNrZWQpIHtcbiAgICByZXR1cm4ge1xuICAgICAgZXZlbnRfaWQ6IGRhdGEuZXZlbnRJZCxcbiAgICAgIGNyZWF0ZWRfYXQ6IGRhdGEuY3JlYXRlZEF0LFxuICAgICAgY2F0ZWdvcnk6IGRhdGEuY2F0ZWdvcnksXG4gICAgICBhdHRyaWJ1dGVzOiB7XG4gICAgICAgIHN1Z2dlc3Rpb25faWQ6IGRhdGEuYXR0cmlidXRlcy5zdWdnZXN0aW9uSWQsXG4gICAgICB9LFxuICAgIH07XG4gIH1cblxuICBpZiAoZGF0YS5jYXRlZ29yeSA9PT0gVXNlckV2ZW50Q2F0ZWdvcnkuUGFnZVZpc2l0KSB7XG4gICAgcmV0dXJuIHtcbiAgICAgIGV2ZW50X2lkOiBkYXRhLmV2ZW50SWQsXG4gICAgICBjcmVhdGVkX2F0OiBkYXRhLmNyZWF0ZWRBdCxcbiAgICAgIGNhdGVnb3J5OiBkYXRhLmNhdGVnb3J5LFxuICAgICAgYXR0cmlidXRlczoge1xuICAgICAgICB1cmw6IGRhdGEuYXR0cmlidXRlcy51cmwsXG4gICAgICAgIHBhZ2VfdmlzaXRfY2F0ZWdvcnk6IGRhdGEuYXR0cmlidXRlcy5wYWdlVmlzaXRDYXRlZ29yeSxcbiAgICAgIH0sXG4gICAgfTtcbiAgfVxuXG4gIGlmIChkYXRhLmNhdGVnb3J5ID09PSBVc2VyRXZlbnRDYXRlZ29yeS5Gb3JtU3VibWl0dGVkKSB7XG4gICAgcmV0dXJuIHtcbiAgICAgIGV2ZW50X2lkOiBkYXRhLmV2ZW50SWQsXG4gICAgICBjcmVhdGVkX2F0OiBkYXRhLmNyZWF0ZWRBdCxcbiAgICAgIGNhdGVnb3J5OiBkYXRhLmNhdGVnb3J5LFxuICAgICAgYXR0cmlidXRlczoge1xuICAgICAgICBmaWxsZWRfc2NoZW1hOiB7IC4uLmRhdGEuYXR0cmlidXRlcy5maWxsZWRTY2hlbWEgfSxcbiAgICAgICAgZm9ybV9yZXNwb25zZV9pZDogZGF0YS5hdHRyaWJ1dGVzLmZvcm1SZXNwb25zZUlkLFxuICAgICAgICBmb3JtX3R5cGU6IGRhdGEuYXR0cmlidXRlcy5mb3JtVHlwZSxcbiAgICAgIH0sXG4gICAgfTtcbiAgfVxuXG4gIC8vIFRoaXMgaXMgdGhlIGRlZmF1bHQgYXBwX2xvYWRlZCBldmVudCwgd2hlbiB3ZSBzdGFydCB0byB1c2UgYXBwX3VubG9hZGVkIHdlIG5lZWQgdG8gaGFuZGxlIGl0IGhlcmVcbiAgcmV0dXJuIHtcbiAgICBldmVudF9pZDogZGF0YS5ldmVudElkLFxuICAgIGNyZWF0ZWRfYXQ6IGRhdGEuY3JlYXRlZEF0LFxuICAgIGNhdGVnb3J5OiBkYXRhLmNhdGVnb3J5LFxuICB9O1xufTtcbiJdLCJtYXBwaW5ncyI6Ijs7O0FBUUEsTUFBYSwrQkFBK0IsU0FBc0M7QUFDaEYsS0FDRSxLQUFLLGFBQWEsa0JBQWtCLFlBQ3BDLEtBQUssYUFBYSxrQkFBa0IsVUFFcEMsUUFBTztFQUNMLFVBQVUsS0FBSztFQUNmLFlBQVksS0FBSztFQUNqQixVQUFVLEtBQUs7RUFDZixZQUFZO0dBQ1YsWUFBWSxLQUFLLFdBQVc7R0FDNUIsbUJBQW1CLEtBQUssV0FBVztHQUNuQyxLQUFLLEtBQUssV0FBVztHQUN0QjtFQUNGO0FBR0gsS0FBSSxLQUFLLGFBQWEsa0JBQWtCLFNBQ3RDLFFBQU87RUFDTCxVQUFVLEtBQUs7RUFDZixZQUFZLEtBQUs7RUFDakIsVUFBVSxLQUFLO0VBQ2YsWUFBWTtHQUNWLFVBQVUscUJBQXFCO0dBQy9CLFlBQVksRUFFVixJQUFLLEtBQUssV0FBVyxXQUErQixJQUNyRDtHQUNGO0VBQ0Y7QUFHSCxLQUFJLEtBQUssYUFBYSxrQkFBa0IsV0FDdEMsUUFBTztFQUNMLFVBQVUsS0FBSztFQUNmLFlBQVksS0FBSztFQUNqQixVQUFVLEtBQUs7RUFDZixZQUFZLEVBQ1YsT0FBTyxLQUFLLFdBQVcsT0FDeEI7RUFDRjtBQUdILEtBQUksS0FBSyxhQUFhLGtCQUFrQixPQUN0QyxRQUFPO0VBQ0wsVUFBVSxLQUFLO0VBQ2YsWUFBWSxLQUFLO0VBQ2pCLFVBQVUsS0FBSztFQUNmLFlBQVk7R0FDVixhQUFhLEtBQUssV0FBVztHQUM3QixrQkFBa0IsS0FBSyxXQUFXO0dBQ25DO0VBQ0Y7QUFHSCxLQUFJLEtBQUssYUFBYSxrQkFBa0Isa0JBQ3RDLFFBQU87RUFDTCxVQUFVLEtBQUs7RUFDZixZQUFZLEtBQUs7RUFDakIsVUFBVSxLQUFLO0VBQ2YsWUFBWSxFQUNWLGVBQWUsS0FBSyxXQUFXLGNBQ2hDO0VBQ0Y7QUFHSCxLQUFJLEtBQUssYUFBYSxrQkFBa0IsVUFDdEMsUUFBTztFQUNMLFVBQVUsS0FBSztFQUNmLFlBQVksS0FBSztFQUNqQixVQUFVLEtBQUs7RUFDZixZQUFZO0dBQ1YsS0FBSyxLQUFLLFdBQVc7R0FDckIscUJBQXFCLEtBQUssV0FBVztHQUN0QztFQUNGO0FBR0gsS0FBSSxLQUFLLGFBQWEsa0JBQWtCLGNBQ3RDLFFBQU87RUFDTCxVQUFVLEtBQUs7RUFDZixZQUFZLEtBQUs7RUFDakIsVUFBVSxLQUFLO0VBQ2YsWUFBWTtHQUNWLGVBQWUsRUFBRSxHQUFHLEtBQUssV0FBVyxjQUFjO0dBQ2xELGtCQUFrQixLQUFLLFdBQVc7R0FDbEMsV0FBVyxLQUFLLFdBQVc7R0FDNUI7RUFDRjtBQUlILFFBQU87RUFDTCxVQUFVLEtBQUs7RUFDZixZQUFZLEtBQUs7RUFDakIsVUFBVSxLQUFLO0VBQ2hCIn0=

package/dist/application/utils/divideArray.cjs

@@ -0,0 +1,11 @@
+
+//#region src/application/utils/divideArray.ts
+const divideArray = (array, size) => {
+	const rows = [];
+	for (let i = 0; i < size; i += 1) rows.push(array.filter((_, index) => index % size === i));
+	return rows;
+};
+
+//#endregion
+exports.divideArray = divideArray;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGl2aWRlQXJyYXkuY2pzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hcHBsaWNhdGlvbi91dGlscy9kaXZpZGVBcnJheS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgZGl2aWRlQXJyYXkgPSA8VD4oYXJyYXk6IFRbXSwgc2l6ZTogbnVtYmVyKSA9PiB7XG4gIGNvbnN0IHJvd3MgPSBbXTtcbiAgZm9yIChsZXQgaSA9IDA7IGkgPCBzaXplOyBpICs9IDEpIHtcbiAgICByb3dzLnB1c2goYXJyYXkuZmlsdGVyKChfOiBULCBpbmRleDogbnVtYmVyKSA9PiBpbmRleCAlIHNpemUgPT09IGkpKTtcbiAgfVxuICByZXR1cm4gcm93cztcbn07XG4iXSwibWFwcGluZ3MiOiI7O0FBQUEsTUFBYSxlQUFrQixPQUFZLFNBQWlCO0NBQzFELE1BQU0sT0FBTyxFQUFFO0FBQ2YsTUFBSyxJQUFJLElBQUksR0FBRyxJQUFJLE1BQU0sS0FBSyxFQUM3QixNQUFLLEtBQUssTUFBTSxRQUFRLEdBQU0sVUFBa0IsUUFBUSxTQUFTLEVBQUUsQ0FBQztBQUV0RSxRQUFPIn0=

package/dist/application/utils/divideArray.d.cts

@@ -0,0 +1,5 @@
+//#region src/application/utils/divideArray.d.ts
+declare const divideArray: <T>(array: T[], size: number) => T[][];
+//#endregion
+export { divideArray };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGl2aWRlQXJyYXkuZC5jdHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FwcGxpY2F0aW9uL3V0aWxzL2RpdmlkZUFycmF5LmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlY2xhcmUgY29uc3QgZGl2aWRlQXJyYXk6IDxUPihhcnJheTogVFtdLCBzaXplOiBudW1iZXIpID0+IFRbXVtdO1xuIl0sIm1hcHBpbmdzIjoiO0FBQUEsSUFBVyxjQUFjO0NBQUM7T0FBVztPQUFTO0NBQUUifQ==

package/dist/application/utils/divideArray.d.ts

@@ -0,0 +1,5 @@
+//#region src/application/utils/divideArray.d.ts
+declare const divideArray: <T>(array: T[], size: number) => T[][];
+//#endregion
+export { divideArray };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGl2aWRlQXJyYXkuZC50cyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXBwbGljYXRpb24vdXRpbHMvZGl2aWRlQXJyYXkuZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZGVjbGFyZSBjb25zdCBkaXZpZGVBcnJheTogPFQ+KGFycmF5OiBUW10sIHNpemU6IG51bWJlcikgPT4gVFtdW107XG4iXSwibWFwcGluZ3MiOiI7QUFBQSxJQUFXLGNBQWM7Q0FBQztPQUFXO09BQVM7Q0FBRSJ9

package/dist/application/utils/divideArray.js

@@ -0,0 +1,10 @@
+//#region src/application/utils/divideArray.ts
+const divideArray = (array, size) => {
+	const rows = [];
+	for (let i = 0; i < size; i += 1) rows.push(array.filter((_, index) => index % size === i));
+	return rows;
+};
+
+//#endregion
+export { divideArray };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGl2aWRlQXJyYXkuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FwcGxpY2F0aW9uL3V0aWxzL2RpdmlkZUFycmF5LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBkaXZpZGVBcnJheSA9IDxUPihhcnJheTogVFtdLCBzaXplOiBudW1iZXIpID0+IHtcbiAgY29uc3Qgcm93cyA9IFtdO1xuICBmb3IgKGxldCBpID0gMDsgaSA8IHNpemU7IGkgKz0gMSkge1xuICAgIHJvd3MucHVzaChhcnJheS5maWx0ZXIoKF86IFQsIGluZGV4OiBudW1iZXIpID0+IGluZGV4ICUgc2l6ZSA9PT0gaSkpO1xuICB9XG4gIHJldHVybiByb3dzO1xufTtcbiJdLCJtYXBwaW5ncyI6IjtBQUFBLE1BQWEsZUFBa0IsT0FBWSxTQUFpQjtDQUMxRCxNQUFNLE9BQU8sRUFBRTtBQUNmLE1BQUssSUFBSSxJQUFJLEdBQUcsSUFBSSxNQUFNLEtBQUssRUFDN0IsTUFBSyxLQUFLLE1BQU0sUUFBUSxHQUFNLFVBQWtCLFFBQVEsU0FBUyxFQUFFLENBQUM7QUFFdEUsUUFBTyJ9

package/dist/application/utils/domObserver.cjs

@@ -0,0 +1,87 @@
+const require_elementObserver = require('./elementObserver.cjs');
+
+//#region src/application/utils/domObserver.ts
+/**
+* This class manages a `MutationObserver` for the `document.body`. It monitors nodes that are
+* added or removed from the DOM and notifies the observers for each observable element
+* when they are ready to be watched.
+*
+* How that works:
+*
+* When the `observe` function is called, it attaches a `MutationObserver` to the `document.body` element.
+* All changes to `document.body` are tracked by this observer. When changes are detected, the `MutationObserver`
+* iterates through all added and removed nodes and checks if each node exists in the main map of observable elements.
+*
+* If a match is found, it notifies the corresponding `ElementObserver` instance to start monitoring changes for that element.
+*
+* The primary `MutationObserver` remains active until the `destroy` function is called. Calling `destroy` will disconnect all
+* individual element observers and release any associated resources.
+*
+* There is no need to explicitly call the `observe` function. It is automatically invoked when a `useElementObserver` hook is instantiated.
+*
+*/
+var DOMObserver = class {
+	static {
+		this.listeners = /* @__PURE__ */ new Map();
+	}
+	static notifyAdition(records, nodeMapping) {
+		records.forEach((record) => record.addedNodes.forEach((node) => {
+			nodeMapping.get(node)?.watch(node);
+			nodeMapping.delete(node);
+		}));
+	}
+	static notifyRemoval(records, nodeMapping) {
+		records.forEach((record) => record.removedNodes.forEach((node) => {
+			nodeMapping.get(node)?.destroy();
+			nodeMapping.delete(node);
+		}));
+	}
+	static notifyChildrenChanges(nodeMapping) {
+		Array.from(nodeMapping.values()).forEach((observer) => observer.synchronize());
+	}
+	static mapNodeInstancesToListeners() {
+		const nodeMapping = /* @__PURE__ */ new Map();
+		this.listeners.forEach((observer) => {
+			const node = observer.getNode() || observer.getSelector()?.parse();
+			if (node) nodeMapping.set(node, observer);
+		});
+		return nodeMapping;
+	}
+	static add(selector) {
+		const node = selector.getPattern();
+		let elementObserver = this.listeners.get(node);
+		if (elementObserver) return elementObserver;
+		elementObserver = new require_elementObserver.ElementObserver(selector);
+		this.listeners.set(node, elementObserver);
+		return elementObserver;
+	}
+	static remove(selector) {
+		const node = selector.getPattern();
+		this.listeners.get(node)?.destroy();
+		this.listeners.delete(node);
+	}
+	static observe() {
+		if (!this.documentObserver) {
+			this.documentObserver = new MutationObserver((mutations) => {
+				const nodeMapping = this.mapNodeInstancesToListeners();
+				this.notifyAdition(mutations, nodeMapping);
+				this.notifyRemoval(mutations, nodeMapping);
+				this.notifyChildrenChanges(nodeMapping);
+			});
+			this.documentObserver.observe(document.body, {
+				childList: true,
+				subtree: true
+			});
+		}
+	}
+	static destroy() {
+		this.documentObserver?.disconnect();
+		this.listeners.forEach((listener) => listener.destroy());
+		this.listeners.clear();
+		this.documentObserver = null;
+	}
+};
+
+//#endregion
+exports.DOMObserver = DOMObserver;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/application/utils/domObserver.d.cts

@@ -0,0 +1,39 @@
+import { NodeSelector } from "./nodeSelector.cjs";
+import { ElementObserver } from "./elementObserver.cjs";
+
+//#region src/application/utils/domObserver.d.ts
+
+/**
+ * This class manages a `MutationObserver` for the `document.body`. It monitors nodes that are
+ * added or removed from the DOM and notifies the observers for each observable element
+ * when they are ready to be watched.
+ *
+ * How that works:
+ *
+ * When the `observe` function is called, it attaches a `MutationObserver` to the `document.body` element.
+ * All changes to `document.body` are tracked by this observer. When changes are detected, the `MutationObserver`
+ * iterates through all added and removed nodes and checks if each node exists in the main map of observable elements.
+ *
+ * If a match is found, it notifies the corresponding `ElementObserver` instance to start monitoring changes for that element.
+ *
+ * The primary `MutationObserver` remains active until the `destroy` function is called. Calling `destroy` will disconnect all
+ * individual element observers and release any associated resources.
+ *
+ * There is no need to explicitly call the `observe` function. It is automatically invoked when a `useElementObserver` hook is instantiated.
+ *
+ */
+declare class DOMObserver {
+  private static documentObserver;
+  private static listeners;
+  private static notifyAdition;
+  private static notifyRemoval;
+  private static notifyChildrenChanges;
+  private static mapNodeInstancesToListeners;
+  static add(selector: NodeSelector): ElementObserver;
+  static remove(selector: NodeSelector): void;
+  static observe(): void;
+  static destroy(): void;
+}
+//#endregion
+export { DOMObserver };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/application/utils/domObserver.d.ts

@@ -0,0 +1,39 @@
+import { NodeSelector } from "./nodeSelector.js";
+import { ElementObserver } from "./elementObserver.js";
+
+//#region src/application/utils/domObserver.d.ts
+
+/**
+ * This class manages a `MutationObserver` for the `document.body`. It monitors nodes that are
+ * added or removed from the DOM and notifies the observers for each observable element
+ * when they are ready to be watched.
+ *
+ * How that works:
+ *
+ * When the `observe` function is called, it attaches a `MutationObserver` to the `document.body` element.
+ * All changes to `document.body` are tracked by this observer. When changes are detected, the `MutationObserver`
+ * iterates through all added and removed nodes and checks if each node exists in the main map of observable elements.
+ *
+ * If a match is found, it notifies the corresponding `ElementObserver` instance to start monitoring changes for that element.
+ *
+ * The primary `MutationObserver` remains active until the `destroy` function is called. Calling `destroy` will disconnect all
+ * individual element observers and release any associated resources.
+ *
+ * There is no need to explicitly call the `observe` function. It is automatically invoked when a `useElementObserver` hook is instantiated.
+ *
+ */
+declare class DOMObserver {
+  private static documentObserver;
+  private static listeners;
+  private static notifyAdition;
+  private static notifyRemoval;
+  private static notifyChildrenChanges;
+  private static mapNodeInstancesToListeners;
+  static add(selector: NodeSelector): ElementObserver;
+  static remove(selector: NodeSelector): void;
+  static observe(): void;
+  static destroy(): void;
+}
+//#endregion
+export { DOMObserver };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/application/utils/domObserver.js

@@ -0,0 +1,87 @@
+import { ElementObserver } from "./elementObserver.js";
+
+//#region src/application/utils/domObserver.ts
+/**
+* This class manages a `MutationObserver` for the `document.body`. It monitors nodes that are
+* added or removed from the DOM and notifies the observers for each observable element
+* when they are ready to be watched.
+*
+* How that works:
+*
+* When the `observe` function is called, it attaches a `MutationObserver` to the `document.body` element.
+* All changes to `document.body` are tracked by this observer. When changes are detected, the `MutationObserver`
+* iterates through all added and removed nodes and checks if each node exists in the main map of observable elements.
+*
+* If a match is found, it notifies the corresponding `ElementObserver` instance to start monitoring changes for that element.
+*
+* The primary `MutationObserver` remains active until the `destroy` function is called. Calling `destroy` will disconnect all
+* individual element observers and release any associated resources.
+*
+* There is no need to explicitly call the `observe` function. It is automatically invoked when a `useElementObserver` hook is instantiated.
+*
+*/
+var DOMObserver = class {
+	static {
+		this.listeners = /* @__PURE__ */ new Map();
+	}
+	static notifyAdition(records, nodeMapping) {
+		records.forEach((record) => record.addedNodes.forEach((node) => {
+			nodeMapping.get(node)?.watch(node);
+			nodeMapping.delete(node);
+		}));
+	}
+	static notifyRemoval(records, nodeMapping) {
+		records.forEach((record) => record.removedNodes.forEach((node) => {
+			nodeMapping.get(node)?.destroy();
+			nodeMapping.delete(node);
+		}));
+	}
+	static notifyChildrenChanges(nodeMapping) {
+		Array.from(nodeMapping.values()).forEach((observer) => observer.synchronize());
+	}
+	static mapNodeInstancesToListeners() {
+		const nodeMapping = /* @__PURE__ */ new Map();
+		this.listeners.forEach((observer) => {
+			const node = observer.getNode() || observer.getSelector()?.parse();
+			if (node) nodeMapping.set(node, observer);
+		});
+		return nodeMapping;
+	}
+	static add(selector) {
+		const node = selector.getPattern();
+		let elementObserver = this.listeners.get(node);
+		if (elementObserver) return elementObserver;
+		elementObserver = new ElementObserver(selector);
+		this.listeners.set(node, elementObserver);
+		return elementObserver;
+	}
+	static remove(selector) {
+		const node = selector.getPattern();
+		this.listeners.get(node)?.destroy();
+		this.listeners.delete(node);
+	}
+	static observe() {
+		if (!this.documentObserver) {
+			this.documentObserver = new MutationObserver((mutations) => {
+				const nodeMapping = this.mapNodeInstancesToListeners();
+				this.notifyAdition(mutations, nodeMapping);
+				this.notifyRemoval(mutations, nodeMapping);
+				this.notifyChildrenChanges(nodeMapping);
+			});
+			this.documentObserver.observe(document.body, {
+				childList: true,
+				subtree: true
+			});
+		}
+	}
+	static destroy() {
+		this.documentObserver?.disconnect();
+		this.listeners.forEach((listener) => listener.destroy());
+		this.listeners.clear();
+		this.documentObserver = null;
+	}
+};
+
+//#endregion
+export { DOMObserver };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9tT2JzZXJ2ZXIuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FwcGxpY2F0aW9uL3V0aWxzL2RvbU9ic2VydmVyLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVsZW1lbnRPYnNlcnZlciB9IGZyb20gJy4vZWxlbWVudE9ic2VydmVyJztcbmltcG9ydCB7IE5vZGVTZWxlY3RvciB9IGZyb20gJy4vbm9kZVNlbGVjdG9yJztcblxuLyoqXG4gKiBUaGlzIGNsYXNzIG1hbmFnZXMgYSBgTXV0YXRpb25PYnNlcnZlcmAgZm9yIHRoZSBgZG9jdW1lbnQuYm9keWAuIEl0IG1vbml0b3JzIG5vZGVzIHRoYXQgYXJlXG4gKiBhZGRlZCBvciByZW1vdmVkIGZyb20gdGhlIERPTSBhbmQgbm90aWZpZXMgdGhlIG9ic2VydmVycyBmb3IgZWFjaCBvYnNlcnZhYmxlIGVsZW1lbnRcbiAqIHdoZW4gdGhleSBhcmUgcmVhZHkgdG8gYmUgd2F0Y2hlZC5cbiAqXG4gKiBIb3cgdGhhdCB3b3JrczpcbiAqXG4gKiBXaGVuIHRoZSBgb2JzZXJ2ZWAgZnVuY3Rpb24gaXMgY2FsbGVkLCBpdCBhdHRhY2hlcyBhIGBNdXRhdGlvbk9ic2VydmVyYCB0byB0aGUgYGRvY3VtZW50LmJvZHlgIGVsZW1lbnQuXG4gKiBBbGwgY2hhbmdlcyB0byBgZG9jdW1lbnQuYm9keWAgYXJlIHRyYWNrZWQgYnkgdGhpcyBvYnNlcnZlci4gV2hlbiBjaGFuZ2VzIGFyZSBkZXRlY3RlZCwgdGhlIGBNdXRhdGlvbk9ic2VydmVyYFxuICogaXRlcmF0ZXMgdGhyb3VnaCBhbGwgYWRkZWQgYW5kIHJlbW92ZWQgbm9kZXMgYW5kIGNoZWNrcyBpZiBlYWNoIG5vZGUgZXhpc3RzIGluIHRoZSBtYWluIG1hcCBvZiBvYnNlcnZhYmxlIGVsZW1lbnRzLlxuICpcbiAqIElmIGEgbWF0Y2ggaXMgZm91bmQsIGl0IG5vdGlmaWVzIHRoZSBjb3JyZXNwb25kaW5nIGBFbGVtZW50T2JzZXJ2ZXJgIGluc3RhbmNlIHRvIHN0YXJ0IG1vbml0b3JpbmcgY2hhbmdlcyBmb3IgdGhhdCBlbGVtZW50LlxuICpcbiAqIFRoZSBwcmltYXJ5IGBNdXRhdGlvbk9ic2VydmVyYCByZW1haW5zIGFjdGl2ZSB1bnRpbCB0aGUgYGRlc3Ryb3lgIGZ1bmN0aW9uIGlzIGNhbGxlZC4gQ2FsbGluZyBgZGVzdHJveWAgd2lsbCBkaXNjb25uZWN0IGFsbFxuICogaW5kaXZpZHVhbCBlbGVtZW50IG9ic2VydmVycyBhbmQgcmVsZWFzZSBhbnkgYXNzb2NpYXRlZCByZXNvdXJjZXMuXG4gKlxuICogVGhlcmUgaXMgbm8gbmVlZCB0byBleHBsaWNpdGx5IGNhbGwgdGhlIGBvYnNlcnZlYCBmdW5jdGlvbi4gSXQgaXMgYXV0b21hdGljYWxseSBpbnZva2VkIHdoZW4gYSBgdXNlRWxlbWVudE9ic2VydmVyYCBob29rIGlzIGluc3RhbnRpYXRlZC5cbiAqXG4gKi9cbmV4cG9ydCBjbGFzcyBET01PYnNlcnZlciB7XG4gIHByaXZhdGUgc3RhdGljIGRvY3VtZW50T2JzZXJ2ZXI6IE11dGF0aW9uT2JzZXJ2ZXIgfCBudWxsO1xuICBwcml2YXRlIHN0YXRpYyBsaXN0ZW5lcnM6IE1hcDxzdHJpbmcsIEVsZW1lbnRPYnNlcnZlcj4gPSBuZXcgTWFwKCk7XG5cbiAgcHJpdmF0ZSBzdGF0aWMgbm90aWZ5QWRpdGlvbihyZWNvcmRzOiBNdXRhdGlvblJlY29yZFtdLCBub2RlTWFwcGluZzogTWFwPE5vZGUsIEVsZW1lbnRPYnNlcnZlcj4pIHtcbiAgICByZWNvcmRzLmZvckVhY2gocmVjb3JkID0+XG4gICAgICByZWNvcmQuYWRkZWROb2Rlcy5mb3JFYWNoKG5vZGUgPT4ge1xuICAgICAgICBub2RlTWFwcGluZy5nZXQobm9kZSk/LndhdGNoKG5vZGUpO1xuICAgICAgICBub2RlTWFwcGluZy5kZWxldGUobm9kZSk7XG4gICAgICB9KSxcbiAgICApO1xuICB9XG5cbiAgcHJpdmF0ZSBzdGF0aWMgbm90aWZ5UmVtb3ZhbChyZWNvcmRzOiBNdXRhdGlvblJlY29yZFtdLCBub2RlTWFwcGluZzogTWFwPE5vZGUsIEVsZW1lbnRPYnNlcnZlcj4pIHtcbiAgICByZWNvcmRzLmZvckVhY2gocmVjb3JkID0+XG4gICAgICByZWNvcmQucmVtb3ZlZE5vZGVzLmZvckVhY2gobm9kZSA9PiB7XG4gICAgICAgIG5vZGVNYXBwaW5nLmdldChub2RlKT8uZGVzdHJveSgpO1xuICAgICAgICBub2RlTWFwcGluZy5kZWxldGUobm9kZSk7XG4gICAgICB9KSxcbiAgICApO1xuICB9XG5cbiAgcHJpdmF0ZSBzdGF0aWMgbm90aWZ5Q2hpbGRyZW5DaGFuZ2VzKG5vZGVNYXBwaW5nOiBNYXA8Tm9kZSwgRWxlbWVudE9ic2VydmVyPikge1xuICAgIEFycmF5LmZyb20obm9kZU1hcHBpbmcudmFsdWVzKCkpLmZvckVhY2gob2JzZXJ2ZXIgPT4gb2JzZXJ2ZXIuc3luY2hyb25pemUoKSk7XG4gIH1cblxuICBwcml2YXRlIHN0YXRpYyBtYXBOb2RlSW5zdGFuY2VzVG9MaXN0ZW5lcnMoKTogTWFwPE5vZGUsIEVsZW1lbnRPYnNlcnZlcj4ge1xuICAgIGNvbnN0IG5vZGVNYXBwaW5nID0gbmV3IE1hcDxOb2RlLCBFbGVtZW50T2JzZXJ2ZXI+KCk7XG4gICAgdGhpcy5saXN0ZW5lcnMuZm9yRWFjaChvYnNlcnZlciA9PiB7XG4gICAgICBjb25zdCBub2RlID0gb2JzZXJ2ZXIuZ2V0Tm9kZSgpIHx8IG9ic2VydmVyLmdldFNlbGVjdG9yKCk/LnBhcnNlKCk7XG4gICAgICBpZiAobm9kZSkge1xuICAgICAgICBub2RlTWFwcGluZy5zZXQobm9kZSwgb2JzZXJ2ZXIpO1xuICAgICAgfVxuICAgIH0pO1xuICAgIHJldHVybiBub2RlTWFwcGluZztcbiAgfVxuXG4gIHN0YXRpYyBhZGQoc2VsZWN0b3I6IE5vZGVTZWxlY3Rvcik6IEVsZW1lbnRPYnNlcnZlciB7XG4gICAgY29uc3Qgbm9kZSA9IHNlbGVjdG9yLmdldFBhdHRlcm4oKTtcbiAgICBsZXQgZWxlbWVudE9ic2VydmVyID0gdGhpcy5saXN0ZW5lcnMuZ2V0KG5vZGUpO1xuICAgIGlmIChlbGVtZW50T2JzZXJ2ZXIpIHtcbiAgICAgIHJldHVybiBlbGVtZW50T2JzZXJ2ZXI7XG4gICAgfVxuXG4gICAgZWxlbWVudE9ic2VydmVyID0gbmV3IEVsZW1lbnRPYnNlcnZlcihzZWxlY3Rvcik7XG4gICAgdGhpcy5saXN0ZW5lcnMuc2V0KG5vZGUsIGVsZW1lbnRPYnNlcnZlcik7XG4gICAgcmV0dXJuIGVsZW1lbnRPYnNlcnZlcjtcbiAgfVxuXG4gIHN0YXRpYyByZW1vdmUoc2VsZWN0b3I6IE5vZGVTZWxlY3Rvcikge1xuICAgIGNvbnN0IG5vZGUgPSBzZWxlY3Rvci5nZXRQYXR0ZXJuKCk7XG4gICAgdGhpcy5saXN0ZW5lcnMuZ2V0KG5vZGUpPy5kZXN0cm95KCk7XG4gICAgdGhpcy5saXN0ZW5lcnMuZGVsZXRlKG5vZGUpO1xuICB9XG5cbiAgc3RhdGljIG9ic2VydmUoKSB7XG4gICAgaWYgKCF0aGlzLmRvY3VtZW50T2JzZXJ2ZXIpIHtcbiAgICAgIHRoaXMuZG9jdW1lbnRPYnNlcnZlciA9IG5ldyBNdXRhdGlvbk9ic2VydmVyKG11dGF0aW9ucyA9PiB7XG4gICAgICAgIGNvbnN0IG5vZGVNYXBwaW5nID0gdGhpcy5tYXBOb2RlSW5zdGFuY2VzVG9MaXN0ZW5lcnMoKTtcbiAgICAgICAgdGhpcy5ub3RpZnlBZGl0aW9uKG11dGF0aW9ucywgbm9kZU1hcHBpbmcpO1xuICAgICAgICB0aGlzLm5vdGlmeVJlbW92YWwobXV0YXRpb25zLCBub2RlTWFwcGluZyk7XG4gICAgICAgIHRoaXMubm90aWZ5Q2hpbGRyZW5DaGFuZ2VzKG5vZGVNYXBwaW5nKTtcbiAgICAgIH0pO1xuICAgICAgdGhpcy5kb2N1bWVudE9ic2VydmVyLm9ic2VydmUoZG9jdW1lbnQuYm9keSwgeyBjaGlsZExpc3Q6IHRydWUsIHN1YnRyZWU6IHRydWUgfSk7XG4gICAgfVxuICB9XG5cbiAgc3RhdGljIGRlc3Ryb3koKSB7XG4gICAgdGhpcy5kb2N1bWVudE9ic2VydmVyPy5kaXNjb25uZWN0KCk7XG4gICAgdGhpcy5saXN0ZW5lcnMuZm9yRWFjaChsaXN0ZW5lciA9PiBsaXN0ZW5lci5kZXN0cm95KCkpO1xuICAgIHRoaXMubGlzdGVuZXJzLmNsZWFyKCk7XG4gICAgdGhpcy5kb2N1bWVudE9ic2VydmVyID0gbnVsbDtcbiAgfVxufVxuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBc0JBLElBQWEsY0FBYixNQUF5Qjs7bUNBRWtDLElBQUksS0FBSzs7Q0FFbEUsT0FBZSxjQUFjLFNBQTJCLGFBQXlDO0FBQy9GLFVBQVEsU0FBUSxXQUNkLE9BQU8sV0FBVyxTQUFRLFNBQVE7QUFDaEMsZUFBWSxJQUFJLEtBQUssRUFBRSxNQUFNLEtBQUs7QUFDbEMsZUFBWSxPQUFPLEtBQUs7SUFDeEIsQ0FDSDs7Q0FHSCxPQUFlLGNBQWMsU0FBMkIsYUFBeUM7QUFDL0YsVUFBUSxTQUFRLFdBQ2QsT0FBTyxhQUFhLFNBQVEsU0FBUTtBQUNsQyxlQUFZLElBQUksS0FBSyxFQUFFLFNBQVM7QUFDaEMsZUFBWSxPQUFPLEtBQUs7SUFDeEIsQ0FDSDs7Q0FHSCxPQUFlLHNCQUFzQixhQUF5QztBQUM1RSxRQUFNLEtBQUssWUFBWSxRQUFRLENBQUMsQ0FBQyxTQUFRLGFBQVksU0FBUyxhQUFhLENBQUM7O0NBRzlFLE9BQWUsOEJBQTBEO0VBQ3ZFLE1BQU0sOEJBQWMsSUFBSSxLQUE0QjtBQUNwRCxPQUFLLFVBQVUsU0FBUSxhQUFZO0dBQ2pDLE1BQU0sT0FBTyxTQUFTLFNBQVMsSUFBSSxTQUFTLGFBQWEsRUFBRSxPQUFPO0FBQ2xFLE9BQUksS0FDRixhQUFZLElBQUksTUFBTSxTQUFTO0lBRWpDO0FBQ0YsU0FBTzs7Q0FHVCxPQUFPLElBQUksVUFBeUM7RUFDbEQsTUFBTSxPQUFPLFNBQVMsWUFBWTtFQUNsQyxJQUFJLGtCQUFrQixLQUFLLFVBQVUsSUFBSSxLQUFLO0FBQzlDLE1BQUksZ0JBQ0YsUUFBTztBQUdULG9CQUFrQixJQUFJLGdCQUFnQixTQUFTO0FBQy9DLE9BQUssVUFBVSxJQUFJLE1BQU0sZ0JBQWdCO0FBQ3pDLFNBQU87O0NBR1QsT0FBTyxPQUFPLFVBQXdCO0VBQ3BDLE1BQU0sT0FBTyxTQUFTLFlBQVk7QUFDbEMsT0FBSyxVQUFVLElBQUksS0FBSyxFQUFFLFNBQVM7QUFDbkMsT0FBSyxVQUFVLE9BQU8sS0FBSzs7Q0FHN0IsT0FBTyxVQUFVO0FBQ2YsTUFBSSxDQUFDLEtBQUssa0JBQWtCO0FBQzFCLFFBQUssbUJBQW1CLElBQUksa0JBQWlCLGNBQWE7SUFDeEQsTUFBTSxjQUFjLEtBQUssNkJBQTZCO0FBQ3RELFNBQUssY0FBYyxXQUFXLFlBQVk7QUFDMUMsU0FBSyxjQUFjLFdBQVcsWUFBWTtBQUMxQyxTQUFLLHNCQUFzQixZQUFZO0tBQ3ZDO0FBQ0YsUUFBSyxpQkFBaUIsUUFBUSxTQUFTLE1BQU07SUFBRSxXQUFXO0lBQU0sU0FBUztJQUFNLENBQUM7OztDQUlwRixPQUFPLFVBQVU7QUFDZixPQUFLLGtCQUFrQixZQUFZO0FBQ25DLE9BQUssVUFBVSxTQUFRLGFBQVksU0FBUyxTQUFTLENBQUM7QUFDdEQsT0FBSyxVQUFVLE9BQU87QUFDdEIsT0FBSyxtQkFBbUIifQ==

package/dist/application/utils/elementObserver.cjs

@@ -0,0 +1,176 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_mutationHelper = require('./mutationHelper.cjs');
+let react_dom = require("react-dom");
+
+//#region src/application/utils/elementObserver.ts
+/**
+* The `ElementObserver` class monitors all changes related to the specific element it is responsible for.
+* It is automatically instantiated by the `useElementObserver` hook, which manages all instances of this class.
+*
+* How it works:
+*
+* Each instance of `ElementObserver` holds several pieces of information related to the node it is monitoring,
+* such as the node's selector and its `MutationObserver`. This class is responsible for translating raw node
+* changes into a more user-friendly format. For example, when the node is added to the DOM, the `ElementObserver`
+* is notified by the `DOMObserver`, which triggers the `onAdd` callback function on the respective `useElementObserver`
+* instance.
+*
+* Instances of `ElementObserver` are fully managed by the `useElementObserver` hook, requiring no additional configuration.
+* When the hook is destroyed, its corresponding `ElementObserver` instance is automatically removed.
+*
+*/
+var ElementObserver = class {
+	constructor(selector) {
+		this.selector = selector;
+		this.mutation = null;
+		this.node = null;
+		this.eventListeners = /* @__PURE__ */ new Map();
+		this.classAdded = /* @__PURE__ */ new Map();
+		this.classRemoved = /* @__PURE__ */ new Map();
+		this.nodeDisplay = "block";
+		this.addFn = () => {};
+		this.removeFn = () => {};
+		this.changeFn = () => {};
+		this.classChangeFn = () => {};
+		this.addChildFn = void 0;
+		this.removeChildFn = void 0;
+		this.resetFn = () => {};
+	}
+	handleAttributes(mutationRecord) {
+		mutationRecord.filter(require_mutationHelper.MutationHelper.isClass).forEach((mutation) => {
+			require_mutationHelper.MutationHelper.fireClassChange(mutation, this.node, this.classChangeFn);
+			require_mutationHelper.MutationHelper.fireClassAdded(mutation, this.node, this.classAdded);
+			require_mutationHelper.MutationHelper.fireClassRemoved(mutation, this.node, this.classRemoved);
+		});
+	}
+	handleChildList(mutationRecord) {
+		if (!this.addChildFn && !this.removeChildFn) return;
+		mutationRecord.filter(require_mutationHelper.MutationHelper.isChildList).forEach((mutation) => {
+			require_mutationHelper.MutationHelper.fireSubtreeChange(mutation.addedNodes, this.addChildFn);
+			require_mutationHelper.MutationHelper.fireSubtreeChange(mutation.removedNodes, this.removeChildFn);
+		});
+	}
+	addInitialListeners() {
+		this.eventListeners.forEach((v, k) => this.node?.addEventListener(k, v));
+	}
+	clearEventListeners() {
+		this.eventListeners.forEach((v, k) => this.node?.removeEventListener(k, v));
+		this.eventListeners.clear();
+	}
+	renew(newNode) {
+		if (newNode) {
+			this.destroy();
+			this.watch(newNode);
+		}
+	}
+	getSelector() {
+		return this.selector;
+	}
+	getNode() {
+		return this.node;
+	}
+	synchronize() {
+		const parsedNode = this.getSelector().parse();
+		if (this.getNode() !== parsedNode) {
+			this.renew(parsedNode);
+			return;
+		}
+		if (!this.getNode() && parsedNode) {
+			this.watch(parsedNode);
+			return;
+		}
+		if (this.getNode() && !parsedNode) this.destroy();
+	}
+	init() {
+		const node = this.getSelector().parse();
+		if (node) this.watch(node);
+	}
+	watch(node) {
+		if (!this.mutation) {
+			this.mutation = new MutationObserver((mutationRecord) => {
+				this.handleAttributes(mutationRecord);
+				this.handleChildList(mutationRecord);
+				this.changeFn(this.node);
+			});
+			this.mutation.observe(node, {
+				childList: true,
+				subtree: true,
+				attributes: true,
+				attributeOldValue: true
+			});
+			this.node = node;
+			this.addFn(this.node);
+			this.addInitialListeners();
+		}
+	}
+	destroy() {
+		this.resetFn();
+		this.removeFn(this.node);
+		this.mutation?.disconnect();
+		this.clearEventListeners();
+		this.classAdded.clear();
+		this.classRemoved.clear();
+		this.mutation = null;
+		this.node = null;
+	}
+	render(fn) {
+		if (this.node) return (0, react_dom.createPortal)(fn(), this.node);
+	}
+	fire(event) {
+		if (this.node) this.node.dispatchEvent(new MouseEvent(event, {
+			bubbles: true,
+			cancelable: true,
+			view: window
+		}));
+	}
+	show() {
+		const display = this.node?.style.display;
+		if (this.node && display === "none") this.node.style.display = this.nodeDisplay || "block";
+	}
+	hide() {
+		const display = this.node?.style.display;
+		if (this.node && display !== "none") {
+			this.nodeDisplay = display || "block";
+			this.node.style.display = "none";
+		}
+	}
+	registerEvent(event, fn) {
+		if (this.node) {
+			const previousFn = this.eventListeners.get(event);
+			if (previousFn) this.node.removeEventListener(event, previousFn);
+			this.node.addEventListener(event, fn);
+		}
+		this.eventListeners.set(event, fn);
+	}
+	registerOnReset(fn) {
+		this.resetFn = fn;
+	}
+	registerOnChange(fn) {
+		this.changeFn = fn;
+	}
+	registerOnAdd(fn) {
+		this.addFn = fn;
+	}
+	registerOnRemove(fn) {
+		this.removeFn = fn;
+	}
+	registerOnclassChange(fn) {
+		this.classChangeFn = fn;
+	}
+	registerOnAddChild(fn) {
+		this.addChildFn = fn;
+	}
+	registerOnRemoveChild(fn) {
+		this.removeChildFn = fn;
+	}
+	registerOnClassAdded(className, fn) {
+		this.classAdded.set(className, fn);
+	}
+	registerOnClassRemoved(className, fn) {
+		this.classRemoved.set(className, fn);
+	}
+};
+
+//#endregion
+exports.ElementObserver = ElementObserver;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"elementObserver.cjs","names":["MutationHelper"],"sources":["../../../src/application/utils/elementObserver.ts"],"sourcesContent":["import { ReactElement } from 'react';\nimport { createPortal } from 'react-dom';\nimport { MouseEventTypes } from './mouseEventTypes';\nimport { MutationHelper } from './mutationHelper';\nimport { NodeSelector } from './nodeSelector';\n\n/**\n * The `ElementObserver` class monitors all changes related to the specific element it is responsible for.\n * It is automatically instantiated by the `useElementObserver` hook, which manages all instances of this class.\n *\n * How it works:\n *\n * Each instance of `ElementObserver` holds several pieces of information related to the node it is monitoring,\n * such as the node's selector and its `MutationObserver`. This class is responsible for translating raw node\n * changes into a more user-friendly format. For example, when the node is added to the DOM, the `ElementObserver`\n * is notified by the `DOMObserver`, which triggers the `onAdd` callback function on the respective `useElementObserver`\n * instance.\n *\n * Instances of `ElementObserver` are fully managed by the `useElementObserver` hook, requiring no additional configuration.\n * When the hook is destroyed, its corresponding `ElementObserver` instance is automatically removed.\n *\n */\nexport class ElementObserver {\n  private mutation: MutationObserver | null;\n\n  private node: HTMLElement | null;\n\n  private selector: NodeSelector;\n\n  private eventListeners: Map<keyof HTMLElementEventMap, EventListenerOrEventListenerObject>;\n\n  private classAdded: Map<string, () => void>;\n\n  private classRemoved: Map<string, () => void>;\n\n  private nodeDisplay: string;\n\n  private addFn: (el: HTMLElement | null) => void;\n\n  private removeFn: (el: HTMLElement | null) => void;\n\n  private changeFn: (el: HTMLElement | null) => void;\n\n  private classChangeFn: (classes?: DOMTokenList) => void;\n\n  private addChildFn?: () => void;\n\n  private removeChildFn?: () => void;\n\n  private resetFn: () => void;\n\n  constructor(selector: NodeSelector) {\n    this.selector = selector;\n    this.mutation = null;\n    this.node = null;\n    this.eventListeners = new Map();\n    this.classAdded = new Map();\n    this.classRemoved = new Map();\n    this.nodeDisplay = 'block';\n    this.addFn = () => {};\n    this.removeFn = () => {};\n    this.changeFn = () => {};\n    this.classChangeFn = () => {};\n    this.addChildFn = undefined;\n    this.removeChildFn = undefined;\n    this.resetFn = () => {};\n  }\n\n  private handleAttributes(mutationRecord: MutationRecord[]) {\n    mutationRecord.filter(MutationHelper.isClass).forEach(mutation => {\n      MutationHelper.fireClassChange(mutation, this.node, this.classChangeFn);\n      MutationHelper.fireClassAdded(mutation, this.node, this.classAdded);\n      MutationHelper.fireClassRemoved(mutation, this.node, this.classRemoved);\n    });\n  }\n\n  private handleChildList(mutationRecord: MutationRecord[]) {\n    if (!this.addChildFn && !this.removeChildFn) {\n      return;\n    }\n\n    mutationRecord.filter(MutationHelper.isChildList).forEach(mutation => {\n      MutationHelper.fireSubtreeChange(mutation.addedNodes, this.addChildFn);\n      MutationHelper.fireSubtreeChange(mutation.removedNodes, this.removeChildFn);\n    });\n  }\n\n  private addInitialListeners() {\n    this.eventListeners.forEach((v, k) => this.node?.addEventListener(k, v));\n  }\n\n  private clearEventListeners() {\n    this.eventListeners.forEach((v, k) => this.node?.removeEventListener(k, v));\n    this.eventListeners.clear();\n  }\n\n  private renew(newNode: Node | null) {\n    if (newNode) {\n      this.destroy();\n      this.watch(newNode);\n    }\n  }\n\n  getSelector() {\n    return this.selector;\n  }\n\n  getNode() {\n    return this.node;\n  }\n\n  synchronize() {\n    const parsedNode = this.getSelector().parse();\n\n    if (this.getNode() !== parsedNode) {\n      this.renew(parsedNode);\n      return;\n    }\n\n    if (!this.getNode() && parsedNode) {\n      this.watch(parsedNode);\n      return;\n    }\n\n    if (this.getNode() && !parsedNode) {\n      this.destroy();\n    }\n  }\n\n  init() {\n    const node = this.getSelector().parse();\n    if (node) {\n      this.watch(node);\n    }\n  }\n\n  watch(node: Node) {\n    if (!this.mutation) {\n      this.mutation = new MutationObserver(mutationRecord => {\n        this.handleAttributes(mutationRecord);\n        this.handleChildList(mutationRecord);\n        this.changeFn(this.node);\n      });\n      this.mutation.observe(node, {\n        childList: true,\n        subtree: true,\n        attributes: true,\n        attributeOldValue: true,\n      });\n      this.node = node as HTMLElement;\n      this.addFn(this.node);\n      this.addInitialListeners();\n    }\n  }\n\n  destroy() {\n    this.resetFn();\n    this.removeFn(this.node);\n    this.mutation?.disconnect();\n    this.clearEventListeners();\n    this.classAdded.clear();\n    this.classRemoved.clear();\n    this.mutation = null;\n    this.node = null;\n  }\n\n  render(fn: () => ReactElement) {\n    if (this.node) {\n      return createPortal(fn(), this.node);\n    }\n  }\n\n  fire(event: MouseEventTypes) {\n    if (this.node) {\n      this.node.dispatchEvent(\n        new MouseEvent(event, {\n          bubbles: true,\n          cancelable: true,\n          view: window,\n        }),\n      );\n    }\n  }\n\n  show() {\n    const display = this.node?.style.display;\n    if (this.node && display === 'none') {\n      this.node.style.display = this.nodeDisplay || 'block';\n    }\n  }\n\n  hide() {\n    const display = this.node?.style.display;\n    if (this.node && display !== 'none') {\n      this.nodeDisplay = display || 'block';\n      this.node.style.display = 'none';\n    }\n  }\n\n  registerEvent(event: keyof HTMLElementEventMap, fn: EventListenerOrEventListenerObject) {\n    if (this.node) {\n      const previousFn = this.eventListeners.get(event);\n      if (previousFn) {\n        this.node.removeEventListener(event, previousFn);\n      }\n      this.node.addEventListener(event, fn);\n    }\n    this.eventListeners.set(event, fn);\n  }\n\n  registerOnReset(fn: () => void) {\n    this.resetFn = fn;\n  }\n\n  registerOnChange(fn: (el: HTMLElement | null) => void) {\n    this.changeFn = fn;\n  }\n\n  registerOnAdd(fn: (el: HTMLElement | null) => void) {\n    this.addFn = fn;\n  }\n\n  registerOnRemove(fn: (el: HTMLElement | null) => void) {\n    this.removeFn = fn;\n  }\n\n  registerOnclassChange(fn: (classes?: DOMTokenList) => void) {\n    this.classChangeFn = fn;\n  }\n\n  registerOnAddChild(fn: (classes?: DOMTokenList) => void) {\n    this.addChildFn = fn;\n  }\n\n  registerOnRemoveChild(fn: (classes?: DOMTokenList) => void) {\n    this.removeChildFn = fn;\n  }\n\n  registerOnClassAdded(className: string, fn: () => void) {\n    this.classAdded.set(className, fn);\n  }\n\n  registerOnClassRemoved(className: string, fn: () => void) {\n    this.classRemoved.set(className, fn);\n  }\n}\n"],"mappings":"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"}