@envive-ai/react-hooks 0.1.5 → 0.1.7

package/dist/domObserver-B6cRGTny.js

@@ -0,0 +1,285 @@
+import { createPortal } from "react-dom";
+
+//#region src/application/utils/mutationHelper.ts
+const compareTokens = (original, comparison) => {
+	const originalTokens = new Set(original.split(" "));
+	const comparisonTokens = new Set(comparison.split(" "));
+	return [...originalTokens].filter((token) => !comparisonTokens.has(token));
+};
+var MutationHelper = class {
+	static fireClassChange(record, node, fn) {
+		if (node && record.oldValue !== node?.classList.value) fn(node?.classList);
+	}
+	static fireClassAdded(record, node, classMap) {
+		if (node && record.oldValue) compareTokens(node?.classList.value, record.oldValue).forEach((className) => classMap.get(className)?.());
+	}
+	static fireClassRemoved(record, node, classMap) {
+		if (node && record.oldValue) compareTokens(record.oldValue, node?.classList.value).forEach((className) => classMap.get(className)?.());
+	}
+	static fireSubtreeChange(nodes, fn) {
+		nodes.length && fn?.(nodes);
+	}
+	static isClass(mutation) {
+		return mutation.type === "attributes" && mutation.attributeName === "class";
+	}
+	static isChildList(mutation) {
+		return mutation.type === "childList";
+	}
+};
+
+//#endregion
+//#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(MutationHelper.isClass).forEach((mutation) => {
+			MutationHelper.fireClassChange(mutation, this.node, this.classChangeFn);
+			MutationHelper.fireClassAdded(mutation, this.node, this.classAdded);
+			MutationHelper.fireClassRemoved(mutation, this.node, this.classRemoved);
+		});
+	}
+	handleChildList(mutationRecord) {
+		if (!this.addChildFn && !this.removeChildFn) return;
+		mutationRecord.filter(MutationHelper.isChildList).forEach((mutation) => {
+			MutationHelper.fireSubtreeChange(mutation.addedNodes, this.addChildFn);
+			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 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
+//#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, ElementObserver, MutationHelper };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"domObserver-B6cRGTny.js","names":[],"sources":["../src/application/utils/mutationHelper.ts","../src/application/utils/elementObserver.ts","../src/application/utils/domObserver.ts"],"sourcesContent":["const compareTokens = (original: string, comparison: string) => {\n  const originalTokens = new Set(original.split(' '));\n  const comparisonTokens = new Set(comparison.split(' '));\n  return [...originalTokens].filter((token) => !comparisonTokens.has(token));\n};\n\nexport class MutationHelper {\n  static fireClassChange(\n    record: MutationRecord,\n    node: HTMLElement | null,\n    fn: (classes: DOMTokenList) => void,\n  ) {\n    if (node && record.oldValue !== node?.classList.value) {\n      fn(node?.classList);\n    }\n  }\n\n  static fireClassAdded(\n    record: MutationRecord,\n    node: HTMLElement | null,\n    classMap: Map<string, () => void>,\n  ) {\n    if (node && record.oldValue) {\n      const tokens = compareTokens(node?.classList.value, record.oldValue);\n      tokens.forEach((className) => classMap.get(className)?.());\n    }\n  }\n\n  static fireClassRemoved(\n    record: MutationRecord,\n    node: HTMLElement | null,\n    classMap: Map<string, () => void>,\n  ) {\n    if (node && record.oldValue) {\n      const tokens = compareTokens(record.oldValue, node?.classList.value);\n      tokens.forEach((className) => classMap.get(className)?.());\n    }\n  }\n\n  static fireSubtreeChange(nodes: NodeList, fn?: (nodes: NodeList) => void) {\n    nodes.length && fn?.(nodes);\n  }\n\n  static isClass(mutation: MutationRecord) {\n    return mutation.type === 'attributes' && mutation.attributeName === 'class';\n  }\n\n  static isChildList(mutation: MutationRecord) {\n    return mutation.type === 'childList';\n  }\n}\n","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","import { ElementObserver } from './elementObserver';\nimport { NodeSelector } from './nodeSelector';\n\n/**\n * This class manages a `MutationObserver` for the `document.body`. It monitors nodes that are\n * added or removed from the DOM and notifies the observers for each observable element\n * when they are ready to be watched.\n *\n * How that works:\n *\n * When the `observe` function is called, it attaches a `MutationObserver` to the `document.body` element.\n * All changes to `document.body` are tracked by this observer. When changes are detected, the `MutationObserver`\n * iterates through all added and removed nodes and checks if each node exists in the main map of observable elements.\n *\n * If a match is found, it notifies the corresponding `ElementObserver` instance to start monitoring changes for that element.\n *\n * The primary `MutationObserver` remains active until the `destroy` function is called. Calling `destroy` will disconnect all\n * individual element observers and release any associated resources.\n *\n * There is no need to explicitly call the `observe` function. It is automatically invoked when a `useElementObserver` hook is instantiated.\n *\n */\nexport class DOMObserver {\n  private static documentObserver: MutationObserver | null;\n  private static listeners: Map<string, ElementObserver> = new Map();\n\n  private static notifyAdition(records: MutationRecord[], nodeMapping: Map<Node, ElementObserver>) {\n    records.forEach((record) =>\n      record.addedNodes.forEach((node) => {\n        nodeMapping.get(node)?.watch(node);\n        nodeMapping.delete(node);\n      }),\n    );\n  }\n\n  private static notifyRemoval(records: MutationRecord[], nodeMapping: Map<Node, ElementObserver>) {\n    records.forEach((record) =>\n      record.removedNodes.forEach((node) => {\n        nodeMapping.get(node)?.destroy();\n        nodeMapping.delete(node);\n      }),\n    );\n  }\n\n  private static notifyChildrenChanges(nodeMapping: Map<Node, ElementObserver>) {\n    Array.from(nodeMapping.values()).forEach((observer) => observer.synchronize());\n  }\n\n  private static mapNodeInstancesToListeners(): Map<Node, ElementObserver> {\n    const nodeMapping = new Map<Node, ElementObserver>();\n    this.listeners.forEach((observer) => {\n      const node = observer.getNode() || observer.getSelector()?.parse();\n      if (node) {\n        nodeMapping.set(node, observer);\n      }\n    });\n    return nodeMapping;\n  }\n\n  static add(selector: NodeSelector): ElementObserver {\n    const node = selector.getPattern();\n    let elementObserver = this.listeners.get(node);\n    if (elementObserver) {\n      return elementObserver;\n    }\n\n    elementObserver = new ElementObserver(selector);\n    this.listeners.set(node, elementObserver);\n    return elementObserver;\n  }\n\n  static remove(selector: NodeSelector) {\n    const node = selector.getPattern();\n    this.listeners.get(node)?.destroy();\n    this.listeners.delete(node);\n  }\n\n  static observe() {\n    if (!this.documentObserver) {\n      this.documentObserver = new MutationObserver((mutations) => {\n        const nodeMapping = this.mapNodeInstancesToListeners();\n        this.notifyAdition(mutations, nodeMapping);\n        this.notifyRemoval(mutations, nodeMapping);\n        this.notifyChildrenChanges(nodeMapping);\n      });\n      this.documentObserver.observe(document.body, { childList: true, subtree: true });\n    }\n  }\n\n  static destroy() {\n    this.documentObserver?.disconnect();\n    this.listeners.forEach((listener) => listener.destroy());\n    this.listeners.clear();\n    this.documentObserver = null;\n  }\n}\n"],"mappings":"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"}

package/dist/domObserver-DQZwhPrc.cjs

@@ -0,0 +1,304 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+let react_dom = require("react-dom");
+react_dom = require_chunk.__toESM(react_dom);
+
+//#region src/application/utils/mutationHelper.ts
+const compareTokens = (original, comparison) => {
+	const originalTokens = new Set(original.split(" "));
+	const comparisonTokens = new Set(comparison.split(" "));
+	return [...originalTokens].filter((token) => !comparisonTokens.has(token));
+};
+var MutationHelper = class {
+	static fireClassChange(record, node, fn) {
+		if (node && record.oldValue !== node?.classList.value) fn(node?.classList);
+	}
+	static fireClassAdded(record, node, classMap) {
+		if (node && record.oldValue) compareTokens(node?.classList.value, record.oldValue).forEach((className) => classMap.get(className)?.());
+	}
+	static fireClassRemoved(record, node, classMap) {
+		if (node && record.oldValue) compareTokens(record.oldValue, node?.classList.value).forEach((className) => classMap.get(className)?.());
+	}
+	static fireSubtreeChange(nodes, fn) {
+		nodes.length && fn?.(nodes);
+	}
+	static isClass(mutation) {
+		return mutation.type === "attributes" && mutation.attributeName === "class";
+	}
+	static isChildList(mutation) {
+		return mutation.type === "childList";
+	}
+};
+
+//#endregion
+//#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(MutationHelper.isClass).forEach((mutation) => {
+			MutationHelper.fireClassChange(mutation, this.node, this.classChangeFn);
+			MutationHelper.fireClassAdded(mutation, this.node, this.classAdded);
+			MutationHelper.fireClassRemoved(mutation, this.node, this.classRemoved);
+		});
+	}
+	handleChildList(mutationRecord) {
+		if (!this.addChildFn && !this.removeChildFn) return;
+		mutationRecord.filter(MutationHelper.isChildList).forEach((mutation) => {
+			MutationHelper.fireSubtreeChange(mutation.addedNodes, this.addChildFn);
+			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
+//#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
+Object.defineProperty(exports, 'DOMObserver', {
+  enumerable: true,
+  get: function () {
+    return DOMObserver;
+  }
+});
+Object.defineProperty(exports, 'ElementObserver', {
+  enumerable: true,
+  get: function () {
+    return ElementObserver;
+  }
+});
+Object.defineProperty(exports, 'MutationHelper', {
+  enumerable: true,
+  get: function () {
+    return MutationHelper;
+  }
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"domObserver-DQZwhPrc.cjs","names":[],"sources":["../src/application/utils/mutationHelper.ts","../src/application/utils/elementObserver.ts","../src/application/utils/domObserver.ts"],"sourcesContent":["const compareTokens = (original: string, comparison: string) => {\n  const originalTokens = new Set(original.split(' '));\n  const comparisonTokens = new Set(comparison.split(' '));\n  return [...originalTokens].filter((token) => !comparisonTokens.has(token));\n};\n\nexport class MutationHelper {\n  static fireClassChange(\n    record: MutationRecord,\n    node: HTMLElement | null,\n    fn: (classes: DOMTokenList) => void,\n  ) {\n    if (node && record.oldValue !== node?.classList.value) {\n      fn(node?.classList);\n    }\n  }\n\n  static fireClassAdded(\n    record: MutationRecord,\n    node: HTMLElement | null,\n    classMap: Map<string, () => void>,\n  ) {\n    if (node && record.oldValue) {\n      const tokens = compareTokens(node?.classList.value, record.oldValue);\n      tokens.forEach((className) => classMap.get(className)?.());\n    }\n  }\n\n  static fireClassRemoved(\n    record: MutationRecord,\n    node: HTMLElement | null,\n    classMap: Map<string, () => void>,\n  ) {\n    if (node && record.oldValue) {\n      const tokens = compareTokens(record.oldValue, node?.classList.value);\n      tokens.forEach((className) => classMap.get(className)?.());\n    }\n  }\n\n  static fireSubtreeChange(nodes: NodeList, fn?: (nodes: NodeList) => void) {\n    nodes.length && fn?.(nodes);\n  }\n\n  static isClass(mutation: MutationRecord) {\n    return mutation.type === 'attributes' && mutation.attributeName === 'class';\n  }\n\n  static isChildList(mutation: MutationRecord) {\n    return mutation.type === 'childList';\n  }\n}\n","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","import { ElementObserver } from './elementObserver';\nimport { NodeSelector } from './nodeSelector';\n\n/**\n * This class manages a `MutationObserver` for the `document.body`. It monitors nodes that are\n * added or removed from the DOM and notifies the observers for each observable element\n * when they are ready to be watched.\n *\n * How that works:\n *\n * When the `observe` function is called, it attaches a `MutationObserver` to the `document.body` element.\n * All changes to `document.body` are tracked by this observer. When changes are detected, the `MutationObserver`\n * iterates through all added and removed nodes and checks if each node exists in the main map of observable elements.\n *\n * If a match is found, it notifies the corresponding `ElementObserver` instance to start monitoring changes for that element.\n *\n * The primary `MutationObserver` remains active until the `destroy` function is called. Calling `destroy` will disconnect all\n * individual element observers and release any associated resources.\n *\n * There is no need to explicitly call the `observe` function. It is automatically invoked when a `useElementObserver` hook is instantiated.\n *\n */\nexport class DOMObserver {\n  private static documentObserver: MutationObserver | null;\n  private static listeners: Map<string, ElementObserver> = new Map();\n\n  private static notifyAdition(records: MutationRecord[], nodeMapping: Map<Node, ElementObserver>) {\n    records.forEach((record) =>\n      record.addedNodes.forEach((node) => {\n        nodeMapping.get(node)?.watch(node);\n        nodeMapping.delete(node);\n      }),\n    );\n  }\n\n  private static notifyRemoval(records: MutationRecord[], nodeMapping: Map<Node, ElementObserver>) {\n    records.forEach((record) =>\n      record.removedNodes.forEach((node) => {\n        nodeMapping.get(node)?.destroy();\n        nodeMapping.delete(node);\n      }),\n    );\n  }\n\n  private static notifyChildrenChanges(nodeMapping: Map<Node, ElementObserver>) {\n    Array.from(nodeMapping.values()).forEach((observer) => observer.synchronize());\n  }\n\n  private static mapNodeInstancesToListeners(): Map<Node, ElementObserver> {\n    const nodeMapping = new Map<Node, ElementObserver>();\n    this.listeners.forEach((observer) => {\n      const node = observer.getNode() || observer.getSelector()?.parse();\n      if (node) {\n        nodeMapping.set(node, observer);\n      }\n    });\n    return nodeMapping;\n  }\n\n  static add(selector: NodeSelector): ElementObserver {\n    const node = selector.getPattern();\n    let elementObserver = this.listeners.get(node);\n    if (elementObserver) {\n      return elementObserver;\n    }\n\n    elementObserver = new ElementObserver(selector);\n    this.listeners.set(node, elementObserver);\n    return elementObserver;\n  }\n\n  static remove(selector: NodeSelector) {\n    const node = selector.getPattern();\n    this.listeners.get(node)?.destroy();\n    this.listeners.delete(node);\n  }\n\n  static observe() {\n    if (!this.documentObserver) {\n      this.documentObserver = new MutationObserver((mutations) => {\n        const nodeMapping = this.mapNodeInstancesToListeners();\n        this.notifyAdition(mutations, nodeMapping);\n        this.notifyRemoval(mutations, nodeMapping);\n        this.notifyChildrenChanges(nodeMapping);\n      });\n      this.documentObserver.observe(document.body, { childList: true, subtree: true });\n    }\n  }\n\n  static destroy() {\n    this.documentObserver?.disconnect();\n    this.listeners.forEach((listener) => listener.destroy());\n    this.listeners.clear();\n    this.documentObserver = null;\n  }\n}\n"],"mappings":"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"}