@envive-ai/react-hooks 0.2.10 → 0.2.11

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

@@ -0,0 +1,30 @@
+import { MouseEventTypes } from "../../application/utils/mouseEventTypes.cjs";
+import { NodeSelector } from "../../application/utils/nodeSelector.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,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

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

@@ -0,0 +1,30 @@
+import { MouseEventTypes } from "../../application/utils/mouseEventTypes.js";
+import { NodeSelector } from "../../application/utils/nodeSelector.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/useElementObserver.js

@@ -0,0 +1,177 @@
+import { DOMObserver } from "../../application/utils/domObserver.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":"useElementObserver.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

@@ -1,99 +1,3 @@
-const require_chunk = require('../../chunk-CUT6urMc.cjs');
-let react = require("react");
-react = require_chunk.__toESM(react);
+const require_useGrabAndScroll = require('./useGrabAndScroll.cjs');
 
-//#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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
+exports.useGrabAndScroll = require_useGrabAndScroll.useGrabAndScroll;

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

@@ -1,14 +1,2 @@
-import * as react4 from "react";
-
-//#region src/hooks/GrabAndScroll/useGrabAndScroll.d.ts
-declare const useGrabAndScroll: (enabled: boolean, chunkWidth: number, speed?: number, offset?: number) => {
-  containerRef: react4.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=
+import { useGrabAndScroll } from "./useGrabAndScroll.cjs";
+export { useGrabAndScroll };

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

@@ -1,14 +1,2 @@
-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==
+import { useGrabAndScroll } from "./useGrabAndScroll.js";
+export { useGrabAndScroll };

package/dist/hooks/GrabAndScroll/index.js

@@ -1,97 +1,3 @@
-import { useRef, useState } from "react";
+import { useGrabAndScroll } from "./useGrabAndScroll.js";
 
-//#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 = useRef(null);
-	const [leftArrow, setLeftArrow] = useState(false);
-	const [rightArrow, setRightArrow] = 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
-export { useGrabAndScroll };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+export { useGrabAndScroll };

package/dist/hooks/GrabAndScroll/useGrabAndScroll.cjs

@@ -0,0 +1,96 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+let react = require("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 step = start + distance * easeOutSine(Math.min(timeElapsed / duration, 1));
+		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/useGrabAndScroll.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlR3JhYkFuZFNjcm9sbC5kLmN0cyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvaG9va3MvR3JhYkFuZFNjcm9sbC91c2VHcmFiQW5kU2Nyb2xsLmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlY2xhcmUgY29uc3QgdXNlR3JhYkFuZFNjcm9sbDogKGVuYWJsZWQ6IGJvb2xlYW4sIGNodW5rV2lkdGg6IG51bWJlciwgc3BlZWQ/OiBudW1iZXIsIG9mZnNldD86IG51bWJlcikgPT4ge1xuICAgIGNvbnRhaW5lclJlZjogaW1wb3J0KFwicmVhY3RcIikuUmVmT2JqZWN0PEhUTUxEaXZFbGVtZW50PjtcbiAgICBsZWZ0QXJyb3c6IGJvb2xlYW47XG4gICAgcmlnaHRBcnJvdzogYm9vbGVhbjtcbiAgICBhbmltYXRpb25UcmlnZ2VyOiAoKSA9PiB2b2lkO1xuICAgIG9uTmV4dDogKGNhcmRzVG9TbGlkZTogbnVtYmVyKSA9PiB2b2lkO1xuICAgIG9uUHJldmlvdXM6IChjYXJkc1RvU2xpZGU6IG51bWJlcikgPT4gdm9pZDtcbn07XG4iXSwibWFwcGluZ3MiOiI7OztBQUNBLElBQVcsbUJBQW1CO0NBQUM7T0FBVztPQUFpQixPQUFBO0NBQUEifQ==