@reactuses/core 6.1.0 → 6.1.2

package/README.md

@@ -18,7 +18,7 @@ npm i @reactuses/core
 
 ## MCP Support
 
-If you want to use the MCP (Meta Command Protocol) integration with reactuse, you can easily set it up with the following configuration. This allows you to run the `@reactuses/mcp` utility via `npx` for enhanced command-line support and automation.
+If you want to use the MCP (Model Context Protocol) integration with reactuse, you can easily set it up with the following configuration. This allows you to run the `@reactuses/mcp` utility via `npx` for enhanced command-line support and automation.
 
 Add the following to your configuration:
 

package/dist/index.cjs

@@ -1401,8 +1401,8 @@ function _async_to_generator$5(fn) {
         });
     };
 }
-function _extends$3() {
-    _extends$3 = Object.assign || function(target) {
+function _extends$4() {
+    _extends$4 = Object.assign || function(target) {
         for(var i = 1; i < arguments.length; i++){
             var source = arguments[i];
             for(var key in source){
@@ -1413,7 +1413,7 @@ function _extends$3() {
         }
         return target;
     };
-    return _extends$3.apply(this, arguments);
+    return _extends$4.apply(this, arguments);
 }
 const DEFAULT_OPTIONS = {
     multiple: true,
@@ -1442,7 +1442,7 @@ const useFileDialog = (options = defaultOptions$1)=>{
             if (!inputRef.current) {
                 return;
             }
-            const _options = _extends$3({}, DEFAULT_OPTIONS, options, localOptions);
+            const _options = _extends$4({}, DEFAULT_OPTIONS, options, localOptions);
             inputRef.current.multiple = _options.multiple;
             inputRef.current.accept = _options.accept;
             // Only set capture attribute if it's explicitly provided
@@ -1880,8 +1880,8 @@ function _async_to_generator$4(fn) {
         });
     };
 }
-function _extends$2() {
-    _extends$2 = Object.assign || function(target) {
+function _extends$3() {
+    _extends$3 = Object.assign || function(target) {
         for(var i = 1; i < arguments.length; i++){
             var source = arguments[i];
             for(var key in source){
@@ -1892,15 +1892,15 @@ function _extends$2() {
         }
         return target;
     };
-    return _extends$2.apply(this, arguments);
+    return _extends$3.apply(this, arguments);
 }
 const useInfiniteScroll = (target, onLoadMore, options = defaultOptions$1)=>{
     const savedLoadMore = useLatest(onLoadMore);
     var _options_direction;
     const direction = (_options_direction = options.direction) != null ? _options_direction : 'bottom';
     var _options_distance;
-    const state = useScroll(target, _extends$2({}, options, {
-        offset: _extends$2({
+    const state = useScroll(target, _extends$3({}, options, {
+        offset: _extends$3({
             [direction]: (_options_distance = options.distance) != null ? _options_distance : 0
         }, options.offset)
     }));
@@ -2627,6 +2627,131 @@ function getValue(position) {
     return getComputedStyle(document.documentElement).getPropertyValue(position);
 }
 
+function _extends$2() {
+    _extends$2 = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends$2.apply(this, arguments);
+}
+const initialState = {
+    isScratching: false
+};
+const useScratch = (target, options = {})=>{
+    const { disabled = false } = options;
+    const [state, setState] = useRafState(initialState);
+    const optionsRef = useLatest(options);
+    const refState = React.useRef(state);
+    const refScratching = React.useRef(false);
+    const refAnimationFrame = React.useRef(null);
+    const onMoveEvent = (docX, docY)=>{
+        if (!refScratching.current) {
+            return;
+        }
+        const el = getTargetElement(target);
+        if (!el) {
+            return;
+        }
+        if (refAnimationFrame.current !== null) {
+            cancelAnimationFrame(refAnimationFrame.current);
+        }
+        refAnimationFrame.current = requestAnimationFrame(()=>{
+            const { left, top } = el.getBoundingClientRect();
+            const elX = left + window.scrollX;
+            const elY = top + window.scrollY;
+            const x = docX - elX;
+            const y = docY - elY;
+            setState((oldState)=>{
+                const newState = _extends$2({}, oldState, {
+                    x,
+                    y,
+                    dx: x - (oldState.x || 0),
+                    dy: y - (oldState.y || 0),
+                    end: Date.now(),
+                    isScratching: true
+                });
+                refState.current = newState;
+                (optionsRef.current.onScratch || noop)(newState);
+                return newState;
+            });
+        });
+    };
+    const stopScratching = ()=>{
+        if (!refScratching.current) {
+            return;
+        }
+        refScratching.current = false;
+        const endState = _extends$2({}, refState.current, {
+            isScratching: false
+        });
+        refState.current = endState;
+        (optionsRef.current.onScratchEnd || noop)(endState);
+        setState(endState);
+    };
+    const startScratching = (docX, docY)=>{
+        const el = getTargetElement(target);
+        if (disabled || !el) {
+            return;
+        }
+        refScratching.current = true;
+        const { left, top } = el.getBoundingClientRect();
+        const elX = left + window.scrollX;
+        const elY = top + window.scrollY;
+        const x = docX - elX;
+        const y = docY - elY;
+        const time = Date.now();
+        const newState = {
+            isScratching: true,
+            start: time,
+            end: time,
+            docX,
+            docY,
+            x,
+            y,
+            dx: 0,
+            dy: 0,
+            elH: el.offsetHeight,
+            elW: el.offsetWidth,
+            elX,
+            elY,
+            posX: elX,
+            posY: elY
+        };
+        refState.current = newState;
+        (optionsRef.current.onScratchStart || noop)(newState);
+        setState(newState);
+    };
+    useEventListener('mousedown', (event)=>{
+        event.preventDefault();
+        startScratching(event.pageX || event.clientX, event.pageY || event.clientY);
+    }, target);
+    useEventListener('touchstart', (event)=>{
+        event.preventDefault();
+        startScratching(event.changedTouches[0].pageX || event.changedTouches[0].clientX, event.changedTouches[0].pageY || event.changedTouches[0].clientY);
+    }, target);
+    useEventListener('mousemove', (event)=>{
+        onMoveEvent(event.pageX || event.clientX, event.pageY || event.clientY);
+    }, defaultWindow);
+    useEventListener('touchmove', (event)=>{
+        onMoveEvent(event.changedTouches[0].pageX || event.changedTouches[0].clientX, event.changedTouches[0].pageY || event.changedTouches[0].clientY);
+    }, defaultWindow);
+    useEventListener('mouseup', stopScratching, defaultWindow);
+    useEventListener('touchend', stopScratching, defaultWindow);
+    useUnmount(()=>{
+        if (refAnimationFrame.current !== null) {
+            cancelAnimationFrame(refAnimationFrame.current);
+        }
+    });
+    return state;
+};
+
 const useScriptTag = (src, onLoaded = noop, options = defaultOptions$1)=>{
     const { immediate = true, manual = false, type = 'text/javascript', async = true, crossOrigin, referrerPolicy, noModule, defer, attrs = {} } = options;
     const scriptTag = React.useRef(null);
@@ -4204,6 +4329,112 @@ const useMap = (initialValue)=>{
     };
 };
 
+const useSpeechRecognition = (options = {})=>{
+    const { interimResults = true, continuous = true, maxAlternatives = 1, lang = 'en-US' } = options;
+    const [isListening, setIsListening] = React.useState(false);
+    const [isFinal, setIsFinal] = React.useState(false);
+    const [result, setResult] = React.useState('');
+    const [error, setError] = React.useState(undefined);
+    const recognitionRef = React.useRef(undefined);
+    const SpeechRecognitionClass = defaultWindow && (defaultWindow.SpeechRecognition || defaultWindow.webkitSpeechRecognition);
+    const isSupported = useSupported(()=>SpeechRecognitionClass);
+    const start = useEvent((startOptions)=>{
+        if (!recognitionRef.current) {
+            return;
+        }
+        // Apply options to recognition instance
+        const { interimResults: newInterimResults = interimResults, continuous: newContinuous = continuous, maxAlternatives: newMaxAlternatives = maxAlternatives, lang: newLang = lang } = startOptions || {};
+        recognitionRef.current.interimResults = newInterimResults;
+        recognitionRef.current.continuous = newContinuous;
+        recognitionRef.current.maxAlternatives = newMaxAlternatives;
+        recognitionRef.current.lang = newLang;
+        setIsListening(true);
+    });
+    const stop = useEvent(()=>{
+        setIsListening(false);
+    });
+    const toggle = useEvent((value = !isListening, startOptions)=>{
+        if (value) {
+            start(startOptions);
+        } else {
+            stop();
+        }
+    });
+    // Initialize recognition when supported
+    React.useEffect(()=>{
+        if (!isSupported || !SpeechRecognitionClass) {
+            return;
+        }
+        const recognition = new SpeechRecognitionClass();
+        recognitionRef.current = recognition;
+        // Set up event listeners
+        recognition.onstart = ()=>{
+            setIsListening(true);
+            setIsFinal(false);
+        };
+        recognition.onresult = (event)=>{
+            const currentResult = event.results[event.resultIndex];
+            const { transcript } = currentResult[0];
+            setIsFinal(currentResult.isFinal);
+            setResult(transcript);
+            setError(undefined);
+        };
+        recognition.onerror = (event)=>{
+            setError(event);
+        };
+        recognition.onend = ()=>{
+            setIsListening(false);
+        };
+        return ()=>{
+            if (recognition) {
+                recognition.abort();
+            }
+        };
+    }, [
+        isSupported,
+        SpeechRecognitionClass
+    ]);
+    // Handle listening state changes
+    React.useEffect(()=>{
+        if (!recognitionRef.current) {
+            return;
+        }
+        if (isListening) {
+            try {
+                recognitionRef.current.start();
+            } catch (err) {
+                console.warn('Failed to start speech recognition:', err);
+                setIsListening(false);
+            }
+        } else {
+            try {
+                recognitionRef.current.stop();
+            } catch (err) {
+                console.warn('Failed to stop speech recognition:', err);
+            }
+        }
+    }, [
+        isListening
+    ]);
+    // Cleanup on unmount
+    useUnmount(()=>{
+        if (recognitionRef.current) {
+            recognitionRef.current.abort();
+        }
+    });
+    return {
+        isSupported,
+        isListening,
+        isFinal,
+        recognition: recognitionRef.current,
+        result,
+        error,
+        toggle,
+        start,
+        stop
+    };
+};
+
 exports.assignRef = assignRef;
 exports.defaultOptions = defaultOptions;
 exports.mergeRefs = mergeRefs;
@@ -4291,6 +4522,7 @@ exports.useRafFn = useRafFn;
 exports.useRafState = useRafState;
 exports.useReducedMotion = useReducedMotion;
 exports.useResizeObserver = useResizeObserver;
+exports.useScratch = useScratch;
 exports.useScreenSafeArea = useScreenSafeArea;
 exports.useScriptTag = useScriptTag;
 exports.useScroll = useScroll;
@@ -4298,6 +4530,7 @@ exports.useScrollIntoView = useScrollIntoView;
 exports.useScrollLock = useScrollLock;
 exports.useSessionStorage = useSessionStorage;
 exports.useSetState = useSetState;
+exports.useSpeechRecognition = useSpeechRecognition;
 exports.useSticky = useSticky;
 exports.useSupported = useSupported;
 exports.useTextDirection = useTextDirection;