@envive-ai/react-hooks 0.1.5 → 0.1.7

package/dist/hooks/ElementObserver/index.cjs

@@ -0,0 +1,179 @@
+const require_chunk = require('../../chunk-CUT6urMc.cjs');
+const require_domObserver = require('../../domObserver-DQZwhPrc.cjs');
+let react = require("react");
+react = require_chunk.__toESM(react);
+
+//#region src/hooks/ElementObserver/useElementObserver.ts
+const useElementObserver = (selector) => {
+	const INITIAL_RENDER_STATE = true;
+	const eoRef = (0, react.useRef)(require_domObserver.DOMObserver.add(selector));
+	const [renderBlocked, setRenderBlocked] = (0, react.useState)(INITIAL_RENDER_STATE);
+	/**
+	* Fired every time the HTML element changes.
+	*
+	* @param fn
+	*/
+	const onChange = (fn) => {
+		eoRef.current?.registerOnChange(fn);
+	};
+	/**
+	* Fired when the HTML element is added to the DOM.
+	*
+	* @param fn
+	*/
+	const onAdd = (fn) => {
+		eoRef.current?.registerOnAdd(fn);
+	};
+	/**
+	* Fired when the HTML element is removed from the DOM.
+	*
+	* @param fn
+	*/
+	const onRemove = (fn) => {
+		eoRef.current?.registerOnRemove(fn);
+	};
+	/**
+	* Fired when the class of the HTML element changes.
+	*
+	* @param fn
+	*/
+	const onClassChange = (fn) => {
+		eoRef.current?.registerOnclassChange(fn);
+	};
+	/**
+	* Fired when a class is added to the HTML element.
+	*
+	* @param className
+	* @param fn
+	*/
+	const onClassAdded = (className, fn) => {
+		eoRef.current?.registerOnClassAdded(className, fn);
+	};
+	/**
+	* Fired when a class is removed from the HTML element.
+	*
+	* @param className
+	* @param fn
+	*/
+	const onClassRemoved = (className, fn) => {
+		eoRef.current?.registerOnClassRemoved(className, fn);
+	};
+	/**
+	* Fired when a child element is added to the HTML element.
+	*
+	* @param fn
+	*/
+	const onAddChild = (fn) => {
+		eoRef.current?.registerOnAddChild(fn);
+	};
+	/**
+	* Fired when a child element is removed from the HTML element.
+	*
+	* @param fn
+	*/
+	const onRemoveChild = (fn) => {
+		eoRef.current?.registerOnRemoveChild(fn);
+	};
+	/**
+	* Allows hooking event listeners to the HTML element, such as `focus`, `blur`, etc.
+	*
+	* @param event
+	* @param fn
+	*/
+	const onEvent = (event, fn) => {
+		eoRef.current.registerEvent(event, fn);
+	};
+	/**
+	* Useful when rendering a React.js component inside the HTML element.
+	*
+	* @param fn
+	* @returns
+	*/
+	const render = (fn) => {
+		if (!renderBlocked) return eoRef.current.render(fn);
+	};
+	/**
+	* Checks if the element exists in the DOM.
+	*
+	* @returns
+	*/
+	const exists = () => !!eoRef.current.getNode();
+	/**
+	* Checks if rendering is unblocked.
+	*
+	* @returns
+	*/
+	const isRendered = () => !renderBlocked;
+	/**
+	* Triggers an event for the HTML element.
+	*
+	* @param event
+	*/
+	const fire = (event) => {
+		eoRef.current.fire(event);
+	};
+	/**
+	* Shows the HTML element.
+	*
+	* @returns
+	*/
+	const show = () => eoRef.current.show();
+	/**
+	* Hides the HTML element.
+	*
+	* @returns
+	*/
+	const hide = () => eoRef.current.hide();
+	/**
+	* Blocks the rendering of elements.
+	*
+	* @returns
+	*/
+	const blockRendering = () => setRenderBlocked(true);
+	/**
+	* Unblocks the rendering of elements.
+	*
+	* @returns
+	*/
+	const unblockRendering = () => setRenderBlocked(false);
+	/**
+	* Applies CSS styles to the HTML element.
+	*
+	* @param styles
+	*/
+	const applyStyle = (styles) => {
+		const node = eoRef?.current?.getNode();
+		node && Object.assign(node.style, styles);
+	};
+	(0, react.useEffect)(() => {
+		eoRef.current.init();
+		eoRef.current.registerOnReset(() => setRenderBlocked(INITIAL_RENDER_STATE));
+		require_domObserver.DOMObserver.observe();
+		return () => require_domObserver.DOMObserver.remove(selector);
+	}, [selector.getPattern()]);
+	return {
+		targetNode: eoRef.current.getNode(),
+		onChange,
+		onAdd,
+		onRemove,
+		onClassChange,
+		onClassAdded,
+		onClassRemoved,
+		onAddChild,
+		onRemoveChild,
+		onEvent,
+		blockRendering,
+		unblockRendering,
+		exists,
+		isRendered,
+		render,
+		fire,
+		show,
+		hide,
+		applyStyle
+	};
+};
+
+//#endregion
+exports.useElementObserver = useElementObserver;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.cjs","names":["DOMObserver"],"sources":["../../../src/hooks/ElementObserver/useElementObserver.ts"],"sourcesContent":["import { ReactElement, useEffect, useRef, useState } from 'react';\nimport { DOMObserver } from 'src/application/utils/domObserver';\nimport { ElementObserver } from 'src/application/utils/elementObserver';\nimport { MouseEventTypes } from 'src/application/utils/mouseEventTypes';\nimport { NodeSelector } from 'src/application/utils/nodeSelector';\n\nexport interface ElementObserverUtility {\n  onChange: (fn: (el: HTMLElement | null) => void) => void;\n  onAdd: (fn: (el: HTMLElement | null) => void) => void;\n  onRemove: (fn: (el: HTMLElement | null) => void) => void;\n  onClassChange: (fn: (classes?: DOMTokenList) => void) => void;\n  onClassAdded: (className: string, fn: () => void) => void;\n  onClassRemoved: (className: string, fn: () => void) => void;\n  onAddChild: (fn: (nodes?: DOMTokenList) => void) => void;\n  onRemoveChild: (fn: (nodes?: DOMTokenList) => void) => void;\n  onEvent: <K extends keyof HTMLElementEventMap>(\n    event: K,\n    fn: EventListenerOrEventListenerObject,\n  ) => void;\n  blockRendering: () => void;\n  unblockRendering: () => void;\n  exists: () => boolean;\n  isRendered: () => boolean;\n  render: (fn: () => ReactElement) => ReactElement | undefined;\n  fire: (event: MouseEventTypes) => void;\n  show: () => void;\n  hide: () => void;\n  applyStyle: (styles: React.CSSProperties) => void;\n  targetNode: HTMLElement | null;\n}\n\n/*\n * This hook enables the connection between a `MutationObserver` and a React.js component.\n * It abstracts all the necessary validations and implementations to modify HTML elements,\n * monitor their changes, and interact with them. The only required input is the element's selector.\n *\n * How to use it:\n *\n * Let's assume we want to interact with the following element:\n * `<div id=\"awesome-content\"><content /></div>`\n *\n * To hook into that element, simply do the following:\n * `const element = useElementObserver(SelectorFactory.id(\"awesome-content\"))`\n *\n * With the `ElementObserver` instance in hand, we can interact with the HTML element without having\n * to manage its presence in the DOM. The `onAdd` and `onRemove` functions can be used to determine\n * whether the element is present in the DOM or not, and to ensure interaction occurs only when necessary.\n *\n * @param selector\n * @returns\n */\nexport const useElementObserver = (selector: NodeSelector): ElementObserverUtility => {\n  const INITIAL_RENDER_STATE = true;\n  const eoRef = useRef<ElementObserver>(DOMObserver.add(selector));\n  const [renderBlocked, setRenderBlocked] = useState(INITIAL_RENDER_STATE);\n\n  /**\n   * Fired every time the HTML element changes.\n   *\n   * @param fn\n   */\n  const onChange = (fn: (el: HTMLElement | null) => void) => {\n    eoRef.current?.registerOnChange(fn);\n  };\n\n  /**\n   * Fired when the HTML element is added to the DOM.\n   *\n   * @param fn\n   */\n  const onAdd = (fn: (el: HTMLElement | null) => void) => {\n    eoRef.current?.registerOnAdd(fn);\n  };\n\n  /**\n   * Fired when the HTML element is removed from the DOM.\n   *\n   * @param fn\n   */\n  const onRemove = (fn: (el: HTMLElement | null) => void) => {\n    eoRef.current?.registerOnRemove(fn);\n  };\n\n  /**\n   * Fired when the class of the HTML element changes.\n   *\n   * @param fn\n   */\n  const onClassChange = (fn: (classes?: DOMTokenList) => void) => {\n    eoRef.current?.registerOnclassChange(fn);\n  };\n\n  /**\n   * Fired when a class is added to the HTML element.\n   *\n   * @param className\n   * @param fn\n   */\n  const onClassAdded = (className: string, fn: () => void) => {\n    eoRef.current?.registerOnClassAdded(className, fn);\n  };\n\n  /**\n   * Fired when a class is removed from the HTML element.\n   *\n   * @param className\n   * @param fn\n   */\n  const onClassRemoved = (className: string, fn: () => void) => {\n    eoRef.current?.registerOnClassRemoved(className, fn);\n  };\n\n  /**\n   * Fired when a child element is added to the HTML element.\n   *\n   * @param fn\n   */\n  const onAddChild = (fn: (nodes?: DOMTokenList) => void) => {\n    eoRef.current?.registerOnAddChild(fn);\n  };\n\n  /**\n   * Fired when a child element is removed from the HTML element.\n   *\n   * @param fn\n   */\n  const onRemoveChild = (fn: (nodes?: DOMTokenList) => void) => {\n    eoRef.current?.registerOnRemoveChild(fn);\n  };\n\n  /**\n   * Allows hooking event listeners to the HTML element, such as `focus`, `blur`, etc.\n   *\n   * @param event\n   * @param fn\n   */\n  const onEvent = <K extends keyof HTMLElementEventMap>(\n    event: K,\n    fn: EventListenerOrEventListenerObject,\n  ) => {\n    eoRef.current.registerEvent(event, fn);\n  };\n\n  /**\n   * Useful when rendering a React.js component inside the HTML element.\n   *\n   * @param fn\n   * @returns\n   */\n  const render = (fn: () => ReactElement) => {\n    if (!renderBlocked) {\n      return eoRef.current.render(fn);\n    }\n  };\n\n  /**\n   * Checks if the element exists in the DOM.\n   *\n   * @returns\n   */\n  const exists = () => !!eoRef.current.getNode();\n\n  /**\n   * Checks if rendering is unblocked.\n   *\n   * @returns\n   */\n  const isRendered = () => !renderBlocked;\n\n  /**\n   * Triggers an event for the HTML element.\n   *\n   * @param event\n   */\n  const fire = (event: MouseEventTypes) => {\n    eoRef.current.fire(event);\n  };\n\n  /**\n   * Shows the HTML element.\n   *\n   * @returns\n   */\n  const show = () => eoRef.current.show();\n\n  /**\n   * Hides the HTML element.\n   *\n   * @returns\n   */\n  const hide = () => eoRef.current.hide();\n\n  /**\n   * Blocks the rendering of elements.\n   *\n   * @returns\n   */\n  const blockRendering = () => setRenderBlocked(true);\n\n  /**\n   * Unblocks the rendering of elements.\n   *\n   * @returns\n   */\n  const unblockRendering = () => setRenderBlocked(false);\n\n  /**\n   * Applies CSS styles to the HTML element.\n   *\n   * @param styles\n   */\n  const applyStyle = (styles: React.CSSProperties) => {\n    const node = eoRef?.current?.getNode();\n    node && Object.assign(node.style, styles);\n  };\n\n  useEffect(() => {\n    eoRef.current.init();\n    eoRef.current.registerOnReset(() => setRenderBlocked(INITIAL_RENDER_STATE));\n    DOMObserver.observe();\n    return () => DOMObserver.remove(selector);\n  }, [selector.getPattern()]);\n\n  return {\n    targetNode: eoRef.current.getNode(),\n    onChange,\n    onAdd,\n    onRemove,\n    onClassChange,\n    onClassAdded,\n    onClassRemoved,\n    onAddChild,\n    onRemoveChild,\n    onEvent,\n    blockRendering,\n    unblockRendering,\n    exists,\n    isRendered,\n    render,\n    fire,\n    show,\n    hide,\n    applyStyle,\n  } satisfies ElementObserverUtility;\n};\n"],"mappings":";;;;;;AAmDA,MAAa,sBAAsB,aAAmD;CACpF,MAAM,uBAAuB;CAC7B,MAAM,0BAAgCA,gCAAY,IAAI,SAAS,CAAC;CAChE,MAAM,CAAC,eAAe,wCAA6B,qBAAqB;;;;;;CAOxE,MAAM,YAAY,OAAyC;AACzD,QAAM,SAAS,iBAAiB,GAAG;;;;;;;CAQrC,MAAM,SAAS,OAAyC;AACtD,QAAM,SAAS,cAAc,GAAG;;;;;;;CAQlC,MAAM,YAAY,OAAyC;AACzD,QAAM,SAAS,iBAAiB,GAAG;;;;;;;CAQrC,MAAM,iBAAiB,OAAyC;AAC9D,QAAM,SAAS,sBAAsB,GAAG;;;;;;;;CAS1C,MAAM,gBAAgB,WAAmB,OAAmB;AAC1D,QAAM,SAAS,qBAAqB,WAAW,GAAG;;;;;;;;CASpD,MAAM,kBAAkB,WAAmB,OAAmB;AAC5D,QAAM,SAAS,uBAAuB,WAAW,GAAG;;;;;;;CAQtD,MAAM,cAAc,OAAuC;AACzD,QAAM,SAAS,mBAAmB,GAAG;;;;;;;CAQvC,MAAM,iBAAiB,OAAuC;AAC5D,QAAM,SAAS,sBAAsB,GAAG;;;;;;;;CAS1C,MAAM,WACJ,OACA,OACG;AACH,QAAM,QAAQ,cAAc,OAAO,GAAG;;;;;;;;CASxC,MAAM,UAAU,OAA2B;AACzC,MAAI,CAAC,cACH,QAAO,MAAM,QAAQ,OAAO,GAAG;;;;;;;CASnC,MAAM,eAAe,CAAC,CAAC,MAAM,QAAQ,SAAS;;;;;;CAO9C,MAAM,mBAAmB,CAAC;;;;;;CAO1B,MAAM,QAAQ,UAA2B;AACvC,QAAM,QAAQ,KAAK,MAAM;;;;;;;CAQ3B,MAAM,aAAa,MAAM,QAAQ,MAAM;;;;;;CAOvC,MAAM,aAAa,MAAM,QAAQ,MAAM;;;;;;CAOvC,MAAM,uBAAuB,iBAAiB,KAAK;;;;;;CAOnD,MAAM,yBAAyB,iBAAiB,MAAM;;;;;;CAOtD,MAAM,cAAc,WAAgC;EAClD,MAAM,OAAO,OAAO,SAAS,SAAS;AACtC,UAAQ,OAAO,OAAO,KAAK,OAAO,OAAO;;AAG3C,4BAAgB;AACd,QAAM,QAAQ,MAAM;AACpB,QAAM,QAAQ,sBAAsB,iBAAiB,qBAAqB,CAAC;AAC3E,kCAAY,SAAS;AACrB,eAAaA,gCAAY,OAAO,SAAS;IACxC,CAAC,SAAS,YAAY,CAAC,CAAC;AAE3B,QAAO;EACL,YAAY,MAAM,QAAQ,SAAS;EACnC;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACD"}

package/dist/hooks/ElementObserver/index.d.cts

@@ -0,0 +1,29 @@
+import { MouseEventTypes, NodeSelector } from "../../nodeSelector-XsUa5vNH.cjs";
+import { ReactElement } from "react";
+
+//#region src/hooks/ElementObserver/useElementObserver.d.ts
+interface ElementObserverUtility {
+  onChange: (fn: (el: HTMLElement | null) => void) => void;
+  onAdd: (fn: (el: HTMLElement | null) => void) => void;
+  onRemove: (fn: (el: HTMLElement | null) => void) => void;
+  onClassChange: (fn: (classes?: DOMTokenList) => void) => void;
+  onClassAdded: (className: string, fn: () => void) => void;
+  onClassRemoved: (className: string, fn: () => void) => void;
+  onAddChild: (fn: (nodes?: DOMTokenList) => void) => void;
+  onRemoveChild: (fn: (nodes?: DOMTokenList) => void) => void;
+  onEvent: <K extends keyof HTMLElementEventMap>(event: K, fn: EventListenerOrEventListenerObject) => void;
+  blockRendering: () => void;
+  unblockRendering: () => void;
+  exists: () => boolean;
+  isRendered: () => boolean;
+  render: (fn: () => ReactElement) => ReactElement | undefined;
+  fire: (event: MouseEventTypes) => void;
+  show: () => void;
+  hide: () => void;
+  applyStyle: (styles: React.CSSProperties) => void;
+  targetNode: HTMLElement | null;
+}
+declare const useElementObserver: (selector: NodeSelector) => ElementObserverUtility;
+//#endregion
+export { ElementObserverUtility, useElementObserver };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC5jdHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2hvb2tzL0VsZW1lbnRPYnNlcnZlci91c2VFbGVtZW50T2JzZXJ2ZXIuZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBSZWFjdEVsZW1lbnQgfSBmcm9tICdyZWFjdCc7XG5pbXBvcnQgeyBNb3VzZUV2ZW50VHlwZXMgfSBmcm9tICdzcmMvYXBwbGljYXRpb24vdXRpbHMvbW91c2VFdmVudFR5cGVzJztcbmltcG9ydCB7IE5vZGVTZWxlY3RvciB9IGZyb20gJ3NyYy9hcHBsaWNhdGlvbi91dGlscy9ub2RlU2VsZWN0b3InO1xuZXhwb3J0IGludGVyZmFjZSBFbGVtZW50T2JzZXJ2ZXJVdGlsaXR5IHtcbiAgICBvbkNoYW5nZTogKGZuOiAoZWw6IEhUTUxFbGVtZW50IHwgbnVsbCkgPT4gdm9pZCkgPT4gdm9pZDtcbiAgICBvbkFkZDogKGZuOiAoZWw6IEhUTUxFbGVtZW50IHwgbnVsbCkgPT4gdm9pZCkgPT4gdm9pZDtcbiAgICBvblJlbW92ZTogKGZuOiAoZWw6IEhUTUxFbGVtZW50IHwgbnVsbCkgPT4gdm9pZCkgPT4gdm9pZDtcbiAgICBvbkNsYXNzQ2hhbmdlOiAoZm46IChjbGFzc2VzPzogRE9NVG9rZW5MaXN0KSA9PiB2b2lkKSA9PiB2b2lkO1xuICAgIG9uQ2xhc3NBZGRlZDogKGNsYXNzTmFtZTogc3RyaW5nLCBmbjogKCkgPT4gdm9pZCkgPT4gdm9pZDtcbiAgICBvbkNsYXNzUmVtb3ZlZDogKGNsYXNzTmFtZTogc3RyaW5nLCBmbjogKCkgPT4gdm9pZCkgPT4gdm9pZDtcbiAgICBvbkFkZENoaWxkOiAoZm46IChub2Rlcz86IERPTVRva2VuTGlzdCkgPT4gdm9pZCkgPT4gdm9pZDtcbiAgICBvblJlbW92ZUNoaWxkOiAoZm46IChub2Rlcz86IERPTVRva2VuTGlzdCkgPT4gdm9pZCkgPT4gdm9pZDtcbiAgICBvbkV2ZW50OiA8SyBleHRlbmRzIGtleW9mIEhUTUxFbGVtZW50RXZlbnRNYXA+KGV2ZW50OiBLLCBmbjogRXZlbnRMaXN0ZW5lck9yRXZlbnRMaXN0ZW5lck9iamVjdCkgPT4gdm9pZDtcbiAgICBibG9ja1JlbmRlcmluZzogKCkgPT4gdm9pZDtcbiAgICB1bmJsb2NrUmVuZGVyaW5nOiAoKSA9PiB2b2lkO1xuICAgIGV4aXN0czogKCkgPT4gYm9vbGVhbjtcbiAgICBpc1JlbmRlcmVkOiAoKSA9PiBib29sZWFuO1xuICAgIHJlbmRlcjogKGZuOiAoKSA9PiBSZWFjdEVsZW1lbnQpID0+IFJlYWN0RWxlbWVudCB8IHVuZGVmaW5lZDtcbiAgICBmaXJlOiAoZXZlbnQ6IE1vdXNlRXZlbnRUeXBlcykgPT4gdm9pZDtcbiAgICBzaG93OiAoKSA9PiB2b2lkO1xuICAgIGhpZGU6ICgpID0+IHZvaWQ7XG4gICAgYXBwbHlTdHlsZTogKHN0eWxlczogUmVhY3QuQ1NTUHJvcGVydGllcykgPT4gdm9pZDtcbiAgICB0YXJnZXROb2RlOiBIVE1MRWxlbWVudCB8IG51bGw7XG59XG5leHBvcnQgZGVjbGFyZSBjb25zdCB1c2VFbGVtZW50T2JzZXJ2ZXI6IChzZWxlY3RvcjogTm9kZVNlbGVjdG9yKSA9PiBFbGVtZW50T2JzZXJ2ZXJVdGlsaXR5O1xuIl0sIm1hcHBpbmdzIjoiOzs7O0FBR0EsSUFBVyx5QkFBeUI7Q0FBQztPQUFHO09BQUE7T0FBQTtPQUFBO09BQUE7T0FBQTtPQUFBO09BQUE7T0FBQTtPQUFBO09BQUE7T0FBQTtPQUFBLE1BQUE7T0FBQTtDQUFBO0FBQ3hDLElBQVcscUJBQXFCO0NBQUM7T0FBVztPQUFnQjtDQUFBIn0=

package/dist/hooks/ElementObserver/index.d.ts

@@ -0,0 +1,29 @@
+import { MouseEventTypes, NodeSelector } from "../../nodeSelector-DybpVr-i.js";
+import { ReactElement } from "react";
+
+//#region src/hooks/ElementObserver/useElementObserver.d.ts
+interface ElementObserverUtility {
+  onChange: (fn: (el: HTMLElement | null) => void) => void;
+  onAdd: (fn: (el: HTMLElement | null) => void) => void;
+  onRemove: (fn: (el: HTMLElement | null) => void) => void;
+  onClassChange: (fn: (classes?: DOMTokenList) => void) => void;
+  onClassAdded: (className: string, fn: () => void) => void;
+  onClassRemoved: (className: string, fn: () => void) => void;
+  onAddChild: (fn: (nodes?: DOMTokenList) => void) => void;
+  onRemoveChild: (fn: (nodes?: DOMTokenList) => void) => void;
+  onEvent: <K extends keyof HTMLElementEventMap>(event: K, fn: EventListenerOrEventListenerObject) => void;
+  blockRendering: () => void;
+  unblockRendering: () => void;
+  exists: () => boolean;
+  isRendered: () => boolean;
+  render: (fn: () => ReactElement) => ReactElement | undefined;
+  fire: (event: MouseEventTypes) => void;
+  show: () => void;
+  hide: () => void;
+  applyStyle: (styles: React.CSSProperties) => void;
+  targetNode: HTMLElement | null;
+}
+declare const useElementObserver: (selector: NodeSelector) => ElementObserverUtility;
+//#endregion
+export { ElementObserverUtility, useElementObserver };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/hooks/ElementObserver/index.js

@@ -0,0 +1,177 @@
+import { DOMObserver } from "../../domObserver-B6cRGTny.js";
+import { useEffect, useRef, useState } from "react";
+
+//#region src/hooks/ElementObserver/useElementObserver.ts
+const useElementObserver = (selector) => {
+	const INITIAL_RENDER_STATE = true;
+	const eoRef = useRef(DOMObserver.add(selector));
+	const [renderBlocked, setRenderBlocked] = useState(INITIAL_RENDER_STATE);
+	/**
+	* Fired every time the HTML element changes.
+	*
+	* @param fn
+	*/
+	const onChange = (fn) => {
+		eoRef.current?.registerOnChange(fn);
+	};
+	/**
+	* Fired when the HTML element is added to the DOM.
+	*
+	* @param fn
+	*/
+	const onAdd = (fn) => {
+		eoRef.current?.registerOnAdd(fn);
+	};
+	/**
+	* Fired when the HTML element is removed from the DOM.
+	*
+	* @param fn
+	*/
+	const onRemove = (fn) => {
+		eoRef.current?.registerOnRemove(fn);
+	};
+	/**
+	* Fired when the class of the HTML element changes.
+	*
+	* @param fn
+	*/
+	const onClassChange = (fn) => {
+		eoRef.current?.registerOnclassChange(fn);
+	};
+	/**
+	* Fired when a class is added to the HTML element.
+	*
+	* @param className
+	* @param fn
+	*/
+	const onClassAdded = (className, fn) => {
+		eoRef.current?.registerOnClassAdded(className, fn);
+	};
+	/**
+	* Fired when a class is removed from the HTML element.
+	*
+	* @param className
+	* @param fn
+	*/
+	const onClassRemoved = (className, fn) => {
+		eoRef.current?.registerOnClassRemoved(className, fn);
+	};
+	/**
+	* Fired when a child element is added to the HTML element.
+	*
+	* @param fn
+	*/
+	const onAddChild = (fn) => {
+		eoRef.current?.registerOnAddChild(fn);
+	};
+	/**
+	* Fired when a child element is removed from the HTML element.
+	*
+	* @param fn
+	*/
+	const onRemoveChild = (fn) => {
+		eoRef.current?.registerOnRemoveChild(fn);
+	};
+	/**
+	* Allows hooking event listeners to the HTML element, such as `focus`, `blur`, etc.
+	*
+	* @param event
+	* @param fn
+	*/
+	const onEvent = (event, fn) => {
+		eoRef.current.registerEvent(event, fn);
+	};
+	/**
+	* Useful when rendering a React.js component inside the HTML element.
+	*
+	* @param fn
+	* @returns
+	*/
+	const render = (fn) => {
+		if (!renderBlocked) return eoRef.current.render(fn);
+	};
+	/**
+	* Checks if the element exists in the DOM.
+	*
+	* @returns
+	*/
+	const exists = () => !!eoRef.current.getNode();
+	/**
+	* Checks if rendering is unblocked.
+	*
+	* @returns
+	*/
+	const isRendered = () => !renderBlocked;
+	/**
+	* Triggers an event for the HTML element.
+	*
+	* @param event
+	*/
+	const fire = (event) => {
+		eoRef.current.fire(event);
+	};
+	/**
+	* Shows the HTML element.
+	*
+	* @returns
+	*/
+	const show = () => eoRef.current.show();
+	/**
+	* Hides the HTML element.
+	*
+	* @returns
+	*/
+	const hide = () => eoRef.current.hide();
+	/**
+	* Blocks the rendering of elements.
+	*
+	* @returns
+	*/
+	const blockRendering = () => setRenderBlocked(true);
+	/**
+	* Unblocks the rendering of elements.
+	*
+	* @returns
+	*/
+	const unblockRendering = () => setRenderBlocked(false);
+	/**
+	* Applies CSS styles to the HTML element.
+	*
+	* @param styles
+	*/
+	const applyStyle = (styles) => {
+		const node = eoRef?.current?.getNode();
+		node && Object.assign(node.style, styles);
+	};
+	useEffect(() => {
+		eoRef.current.init();
+		eoRef.current.registerOnReset(() => setRenderBlocked(INITIAL_RENDER_STATE));
+		DOMObserver.observe();
+		return () => DOMObserver.remove(selector);
+	}, [selector.getPattern()]);
+	return {
+		targetNode: eoRef.current.getNode(),
+		onChange,
+		onAdd,
+		onRemove,
+		onClassChange,
+		onClassAdded,
+		onClassRemoved,
+		onAddChild,
+		onRemoveChild,
+		onEvent,
+		blockRendering,
+		unblockRendering,
+		exists,
+		isRendered,
+		render,
+		fire,
+		show,
+		hide,
+		applyStyle
+	};
+};
+
+//#endregion
+export { useElementObserver };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.js","names":[],"sources":["../../../src/hooks/ElementObserver/useElementObserver.ts"],"sourcesContent":["import { ReactElement, useEffect, useRef, useState } from 'react';\nimport { DOMObserver } from 'src/application/utils/domObserver';\nimport { ElementObserver } from 'src/application/utils/elementObserver';\nimport { MouseEventTypes } from 'src/application/utils/mouseEventTypes';\nimport { NodeSelector } from 'src/application/utils/nodeSelector';\n\nexport interface ElementObserverUtility {\n  onChange: (fn: (el: HTMLElement | null) => void) => void;\n  onAdd: (fn: (el: HTMLElement | null) => void) => void;\n  onRemove: (fn: (el: HTMLElement | null) => void) => void;\n  onClassChange: (fn: (classes?: DOMTokenList) => void) => void;\n  onClassAdded: (className: string, fn: () => void) => void;\n  onClassRemoved: (className: string, fn: () => void) => void;\n  onAddChild: (fn: (nodes?: DOMTokenList) => void) => void;\n  onRemoveChild: (fn: (nodes?: DOMTokenList) => void) => void;\n  onEvent: <K extends keyof HTMLElementEventMap>(\n    event: K,\n    fn: EventListenerOrEventListenerObject,\n  ) => void;\n  blockRendering: () => void;\n  unblockRendering: () => void;\n  exists: () => boolean;\n  isRendered: () => boolean;\n  render: (fn: () => ReactElement) => ReactElement | undefined;\n  fire: (event: MouseEventTypes) => void;\n  show: () => void;\n  hide: () => void;\n  applyStyle: (styles: React.CSSProperties) => void;\n  targetNode: HTMLElement | null;\n}\n\n/*\n * This hook enables the connection between a `MutationObserver` and a React.js component.\n * It abstracts all the necessary validations and implementations to modify HTML elements,\n * monitor their changes, and interact with them. The only required input is the element's selector.\n *\n * How to use it:\n *\n * Let's assume we want to interact with the following element:\n * `<div id=\"awesome-content\"><content /></div>`\n *\n * To hook into that element, simply do the following:\n * `const element = useElementObserver(SelectorFactory.id(\"awesome-content\"))`\n *\n * With the `ElementObserver` instance in hand, we can interact with the HTML element without having\n * to manage its presence in the DOM. The `onAdd` and `onRemove` functions can be used to determine\n * whether the element is present in the DOM or not, and to ensure interaction occurs only when necessary.\n *\n * @param selector\n * @returns\n */\nexport const useElementObserver = (selector: NodeSelector): ElementObserverUtility => {\n  const INITIAL_RENDER_STATE = true;\n  const eoRef = useRef<ElementObserver>(DOMObserver.add(selector));\n  const [renderBlocked, setRenderBlocked] = useState(INITIAL_RENDER_STATE);\n\n  /**\n   * Fired every time the HTML element changes.\n   *\n   * @param fn\n   */\n  const onChange = (fn: (el: HTMLElement | null) => void) => {\n    eoRef.current?.registerOnChange(fn);\n  };\n\n  /**\n   * Fired when the HTML element is added to the DOM.\n   *\n   * @param fn\n   */\n  const onAdd = (fn: (el: HTMLElement | null) => void) => {\n    eoRef.current?.registerOnAdd(fn);\n  };\n\n  /**\n   * Fired when the HTML element is removed from the DOM.\n   *\n   * @param fn\n   */\n  const onRemove = (fn: (el: HTMLElement | null) => void) => {\n    eoRef.current?.registerOnRemove(fn);\n  };\n\n  /**\n   * Fired when the class of the HTML element changes.\n   *\n   * @param fn\n   */\n  const onClassChange = (fn: (classes?: DOMTokenList) => void) => {\n    eoRef.current?.registerOnclassChange(fn);\n  };\n\n  /**\n   * Fired when a class is added to the HTML element.\n   *\n   * @param className\n   * @param fn\n   */\n  const onClassAdded = (className: string, fn: () => void) => {\n    eoRef.current?.registerOnClassAdded(className, fn);\n  };\n\n  /**\n   * Fired when a class is removed from the HTML element.\n   *\n   * @param className\n   * @param fn\n   */\n  const onClassRemoved = (className: string, fn: () => void) => {\n    eoRef.current?.registerOnClassRemoved(className, fn);\n  };\n\n  /**\n   * Fired when a child element is added to the HTML element.\n   *\n   * @param fn\n   */\n  const onAddChild = (fn: (nodes?: DOMTokenList) => void) => {\n    eoRef.current?.registerOnAddChild(fn);\n  };\n\n  /**\n   * Fired when a child element is removed from the HTML element.\n   *\n   * @param fn\n   */\n  const onRemoveChild = (fn: (nodes?: DOMTokenList) => void) => {\n    eoRef.current?.registerOnRemoveChild(fn);\n  };\n\n  /**\n   * Allows hooking event listeners to the HTML element, such as `focus`, `blur`, etc.\n   *\n   * @param event\n   * @param fn\n   */\n  const onEvent = <K extends keyof HTMLElementEventMap>(\n    event: K,\n    fn: EventListenerOrEventListenerObject,\n  ) => {\n    eoRef.current.registerEvent(event, fn);\n  };\n\n  /**\n   * Useful when rendering a React.js component inside the HTML element.\n   *\n   * @param fn\n   * @returns\n   */\n  const render = (fn: () => ReactElement) => {\n    if (!renderBlocked) {\n      return eoRef.current.render(fn);\n    }\n  };\n\n  /**\n   * Checks if the element exists in the DOM.\n   *\n   * @returns\n   */\n  const exists = () => !!eoRef.current.getNode();\n\n  /**\n   * Checks if rendering is unblocked.\n   *\n   * @returns\n   */\n  const isRendered = () => !renderBlocked;\n\n  /**\n   * Triggers an event for the HTML element.\n   *\n   * @param event\n   */\n  const fire = (event: MouseEventTypes) => {\n    eoRef.current.fire(event);\n  };\n\n  /**\n   * Shows the HTML element.\n   *\n   * @returns\n   */\n  const show = () => eoRef.current.show();\n\n  /**\n   * Hides the HTML element.\n   *\n   * @returns\n   */\n  const hide = () => eoRef.current.hide();\n\n  /**\n   * Blocks the rendering of elements.\n   *\n   * @returns\n   */\n  const blockRendering = () => setRenderBlocked(true);\n\n  /**\n   * Unblocks the rendering of elements.\n   *\n   * @returns\n   */\n  const unblockRendering = () => setRenderBlocked(false);\n\n  /**\n   * Applies CSS styles to the HTML element.\n   *\n   * @param styles\n   */\n  const applyStyle = (styles: React.CSSProperties) => {\n    const node = eoRef?.current?.getNode();\n    node && Object.assign(node.style, styles);\n  };\n\n  useEffect(() => {\n    eoRef.current.init();\n    eoRef.current.registerOnReset(() => setRenderBlocked(INITIAL_RENDER_STATE));\n    DOMObserver.observe();\n    return () => DOMObserver.remove(selector);\n  }, [selector.getPattern()]);\n\n  return {\n    targetNode: eoRef.current.getNode(),\n    onChange,\n    onAdd,\n    onRemove,\n    onClassChange,\n    onClassAdded,\n    onClassRemoved,\n    onAddChild,\n    onRemoveChild,\n    onEvent,\n    blockRendering,\n    unblockRendering,\n    exists,\n    isRendered,\n    render,\n    fire,\n    show,\n    hide,\n    applyStyle,\n  } satisfies ElementObserverUtility;\n};\n"],"mappings":";;;;AAmDA,MAAa,sBAAsB,aAAmD;CACpF,MAAM,uBAAuB;CAC7B,MAAM,QAAQ,OAAwB,YAAY,IAAI,SAAS,CAAC;CAChE,MAAM,CAAC,eAAe,oBAAoB,SAAS,qBAAqB;;;;;;CAOxE,MAAM,YAAY,OAAyC;AACzD,QAAM,SAAS,iBAAiB,GAAG;;;;;;;CAQrC,MAAM,SAAS,OAAyC;AACtD,QAAM,SAAS,cAAc,GAAG;;;;;;;CAQlC,MAAM,YAAY,OAAyC;AACzD,QAAM,SAAS,iBAAiB,GAAG;;;;;;;CAQrC,MAAM,iBAAiB,OAAyC;AAC9D,QAAM,SAAS,sBAAsB,GAAG;;;;;;;;CAS1C,MAAM,gBAAgB,WAAmB,OAAmB;AAC1D,QAAM,SAAS,qBAAqB,WAAW,GAAG;;;;;;;;CASpD,MAAM,kBAAkB,WAAmB,OAAmB;AAC5D,QAAM,SAAS,uBAAuB,WAAW,GAAG;;;;;;;CAQtD,MAAM,cAAc,OAAuC;AACzD,QAAM,SAAS,mBAAmB,GAAG;;;;;;;CAQvC,MAAM,iBAAiB,OAAuC;AAC5D,QAAM,SAAS,sBAAsB,GAAG;;;;;;;;CAS1C,MAAM,WACJ,OACA,OACG;AACH,QAAM,QAAQ,cAAc,OAAO,GAAG;;;;;;;;CASxC,MAAM,UAAU,OAA2B;AACzC,MAAI,CAAC,cACH,QAAO,MAAM,QAAQ,OAAO,GAAG;;;;;;;CASnC,MAAM,eAAe,CAAC,CAAC,MAAM,QAAQ,SAAS;;;;;;CAO9C,MAAM,mBAAmB,CAAC;;;;;;CAO1B,MAAM,QAAQ,UAA2B;AACvC,QAAM,QAAQ,KAAK,MAAM;;;;;;;CAQ3B,MAAM,aAAa,MAAM,QAAQ,MAAM;;;;;;CAOvC,MAAM,aAAa,MAAM,QAAQ,MAAM;;;;;;CAOvC,MAAM,uBAAuB,iBAAiB,KAAK;;;;;;CAOnD,MAAM,yBAAyB,iBAAiB,MAAM;;;;;;CAOtD,MAAM,cAAc,WAAgC;EAClD,MAAM,OAAO,OAAO,SAAS,SAAS;AACtC,UAAQ,OAAO,OAAO,KAAK,OAAO,OAAO;;AAG3C,iBAAgB;AACd,QAAM,QAAQ,MAAM;AACpB,QAAM,QAAQ,sBAAsB,iBAAiB,qBAAqB,CAAC;AAC3E,cAAY,SAAS;AACrB,eAAa,YAAY,OAAO,SAAS;IACxC,CAAC,SAAS,YAAY,CAAC,CAAC;AAE3B,QAAO;EACL,YAAY,MAAM,QAAQ,SAAS;EACnC;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACD"}

package/dist/hooks/GrabAndScroll/index.cjs

@@ -0,0 +1,99 @@
+const require_chunk = require('../../chunk-CUT6urMc.cjs');
+let react = require("react");
+react = require_chunk.__toESM(react);
+
+//#region src/hooks/GrabAndScroll/useGrabAndScroll.ts
+const animateHorizontalScroll = ({ element, duration, targetScroll, multiply = 1, direction, callback, offset = 0 }) => {
+	const start = element.scrollLeft;
+	const distance = (targetScroll - start) * multiply;
+	const startTime = performance.now();
+	function easeOutSine(x) {
+		return Math.sin(x * Math.PI / 2);
+	}
+	function scrollStep(currentTime) {
+		const timeElapsed = currentTime - startTime;
+		const progress = Math.min(timeElapsed / duration, 1);
+		const easing = easeOutSine(progress);
+		const step = start + distance * easing;
+		const canScroll = (direction === "rt" ? element.scrollLeft < step : element.scrollLeft > step) || !direction;
+		if (step > 0 && canScroll) element.scrollTo(step, 0);
+		if (timeElapsed < duration) requestAnimationFrame(scrollStep);
+		else if (element.scrollLeft + offset === element.scrollWidth) callback?.("rt");
+		else if (element.scrollLeft <= 1) callback?.("lt");
+		else callback?.("ct");
+	}
+	requestAnimationFrame(scrollStep);
+};
+const useGrabAndScroll = (enabled, chunkWidth, speed = 400, offset = 0) => {
+	const containerRef = (0, react.useRef)(null);
+	const [leftArrow, setLeftArrow] = (0, react.useState)(false);
+	const [rightArrow, setRightArrow] = (0, react.useState)(true);
+	const handleArrows = (position) => {
+		switch (position) {
+			case "lt":
+				setLeftArrow(false);
+				setRightArrow(true);
+				break;
+			case "rt":
+				setLeftArrow(true);
+				setRightArrow(false);
+				break;
+			default:
+				setLeftArrow(true);
+				setRightArrow(true);
+		}
+	};
+	const animationTrigger = () => {
+		if (enabled && containerRef.current) {
+			const dist = (containerRef?.current?.scrollLeft || 0) / chunkWidth;
+			const targetScroll = chunkWidth * (Math.floor(dist) + (dist % 1 > .5 ? 1 : 0));
+			animateHorizontalScroll({
+				element: containerRef.current,
+				targetScroll,
+				duration: speed,
+				offset,
+				callback: handleArrows
+			});
+		}
+	};
+	const onNext = (cardsToSlide) => {
+		if (containerRef.current) {
+			const targetScroll = containerRef.current.scrollLeft + chunkWidth;
+			animateHorizontalScroll({
+				element: containerRef.current,
+				targetScroll,
+				duration: speed,
+				direction: "rt",
+				multiply: cardsToSlide,
+				offset,
+				callback: handleArrows
+			});
+		}
+	};
+	const onPrevious = (cardsToSlide) => {
+		if (containerRef.current) {
+			const targetScroll = containerRef.current.scrollLeft - chunkWidth;
+			animateHorizontalScroll({
+				element: containerRef.current,
+				targetScroll,
+				duration: speed,
+				direction: "lt",
+				multiply: cardsToSlide,
+				offset,
+				callback: handleArrows
+			});
+		}
+	};
+	return {
+		containerRef,
+		leftArrow,
+		rightArrow,
+		animationTrigger,
+		onNext,
+		onPrevious
+	};
+};
+
+//#endregion
+exports.useGrabAndScroll = useGrabAndScroll;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/hooks/GrabAndScroll/index.d.cts

@@ -0,0 +1,14 @@
+import * as react0 from "react";
+
+//#region src/hooks/GrabAndScroll/useGrabAndScroll.d.ts
+declare const useGrabAndScroll: (enabled: boolean, chunkWidth: number, speed?: number, offset?: number) => {
+  containerRef: react0.RefObject<HTMLDivElement>;
+  leftArrow: boolean;
+  rightArrow: boolean;
+  animationTrigger: () => void;
+  onNext: (cardsToSlide: number) => void;
+  onPrevious: (cardsToSlide: number) => void;
+};
+//#endregion
+export { useGrabAndScroll };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC5jdHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2hvb2tzL0dyYWJBbmRTY3JvbGwvdXNlR3JhYkFuZFNjcm9sbC5kLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWNsYXJlIGNvbnN0IHVzZUdyYWJBbmRTY3JvbGw6IChlbmFibGVkOiBib29sZWFuLCBjaHVua1dpZHRoOiBudW1iZXIsIHNwZWVkPzogbnVtYmVyLCBvZmZzZXQ/OiBudW1iZXIpID0+IHtcbiAgICBjb250YWluZXJSZWY6IGltcG9ydChcInJlYWN0XCIpLlJlZk9iamVjdDxIVE1MRGl2RWxlbWVudD47XG4gICAgbGVmdEFycm93OiBib29sZWFuO1xuICAgIHJpZ2h0QXJyb3c6IGJvb2xlYW47XG4gICAgYW5pbWF0aW9uVHJpZ2dlcjogKCkgPT4gdm9pZDtcbiAgICBvbk5leHQ6IChjYXJkc1RvU2xpZGU6IG51bWJlcikgPT4gdm9pZDtcbiAgICBvblByZXZpb3VzOiAoY2FyZHNUb1NsaWRlOiBudW1iZXIpID0+IHZvaWQ7XG59O1xuIl0sIm1hcHBpbmdzIjoiOzs7QUFDQSxJQUFXLG1CQUFtQjtDQUFDO09BQVc7T0FBaUIsT0FBQTtDQUFBIn0=

package/dist/hooks/GrabAndScroll/index.d.ts

@@ -0,0 +1,14 @@
+import * as react0 from "react";
+
+//#region src/hooks/GrabAndScroll/useGrabAndScroll.d.ts
+declare const useGrabAndScroll: (enabled: boolean, chunkWidth: number, speed?: number, offset?: number) => {
+  containerRef: react0.RefObject<HTMLDivElement>;
+  leftArrow: boolean;
+  rightArrow: boolean;
+  animationTrigger: () => void;
+  onNext: (cardsToSlide: number) => void;
+  onPrevious: (cardsToSlide: number) => void;
+};
+//#endregion
+export { useGrabAndScroll };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvaG9va3MvR3JhYkFuZFNjcm9sbC91c2VHcmFiQW5kU2Nyb2xsLmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlY2xhcmUgY29uc3QgdXNlR3JhYkFuZFNjcm9sbDogKGVuYWJsZWQ6IGJvb2xlYW4sIGNodW5rV2lkdGg6IG51bWJlciwgc3BlZWQ/OiBudW1iZXIsIG9mZnNldD86IG51bWJlcikgPT4ge1xuICAgIGNvbnRhaW5lclJlZjogaW1wb3J0KFwicmVhY3RcIikuUmVmT2JqZWN0PEhUTUxEaXZFbGVtZW50PjtcbiAgICBsZWZ0QXJyb3c6IGJvb2xlYW47XG4gICAgcmlnaHRBcnJvdzogYm9vbGVhbjtcbiAgICBhbmltYXRpb25UcmlnZ2VyOiAoKSA9PiB2b2lkO1xuICAgIG9uTmV4dDogKGNhcmRzVG9TbGlkZTogbnVtYmVyKSA9PiB2b2lkO1xuICAgIG9uUHJldmlvdXM6IChjYXJkc1RvU2xpZGU6IG51bWJlcikgPT4gdm9pZDtcbn07XG4iXSwibWFwcGluZ3MiOiI7OztBQUNBLElBQVcsbUJBQW1CO0NBQUM7T0FBVztPQUFpQixPQUFBO0NBQUEifQ==