add hw2

node_modules/@react-aria/interactions/dist/utils.mjs

@@ -0,0 +1,157 @@
+import {useLayoutEffect as $6dfIe$useLayoutEffect, useEffectEvent as $6dfIe$useEffectEvent, isFocusable as $6dfIe$isFocusable, getOwnerWindow as $6dfIe$getOwnerWindow, focusWithoutScrolling as $6dfIe$focusWithoutScrolling} from "@react-aria/utils";
+import {useRef as $6dfIe$useRef, useCallback as $6dfIe$useCallback} from "react";
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+function $8a9cb279dc87e130$export$525bc4921d56d4a(nativeEvent) {
+    let event = nativeEvent;
+    event.nativeEvent = nativeEvent;
+    event.isDefaultPrevented = ()=>event.defaultPrevented;
+    // cancelBubble is technically deprecated in the spec, but still supported in all browsers.
+    event.isPropagationStopped = ()=>event.cancelBubble;
+    event.persist = ()=>{};
+    return event;
+}
+function $8a9cb279dc87e130$export$c2b7abe5d61ec696(event, target) {
+    Object.defineProperty(event, 'target', {
+        value: target
+    });
+    Object.defineProperty(event, 'currentTarget', {
+        value: target
+    });
+}
+function $8a9cb279dc87e130$export$715c682d09d639cc(onBlur) {
+    let stateRef = (0, $6dfIe$useRef)({
+        isFocused: false,
+        observer: null
+    });
+    // Clean up MutationObserver on unmount. See below.
+    (0, $6dfIe$useLayoutEffect)(()=>{
+        const state = stateRef.current;
+        return ()=>{
+            if (state.observer) {
+                state.observer.disconnect();
+                state.observer = null;
+            }
+        };
+    }, []);
+    let dispatchBlur = (0, $6dfIe$useEffectEvent)((e)=>{
+        onBlur === null || onBlur === void 0 ? void 0 : onBlur(e);
+    });
+    // This function is called during a React onFocus event.
+    return (0, $6dfIe$useCallback)((e)=>{
+        // React does not fire onBlur when an element is disabled. https://github.com/facebook/react/issues/9142
+        // Most browsers fire a native focusout event in this case, except for Firefox. In that case, we use a
+        // MutationObserver to watch for the disabled attribute, and dispatch these events ourselves.
+        // For browsers that do, focusout fires before the MutationObserver, so onBlur should not fire twice.
+        if (e.target instanceof HTMLButtonElement || e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement || e.target instanceof HTMLSelectElement) {
+            stateRef.current.isFocused = true;
+            let target = e.target;
+            let onBlurHandler = (e)=>{
+                stateRef.current.isFocused = false;
+                if (target.disabled) {
+                    // For backward compatibility, dispatch a (fake) React synthetic event.
+                    let event = $8a9cb279dc87e130$export$525bc4921d56d4a(e);
+                    dispatchBlur(event);
+                }
+                // We no longer need the MutationObserver once the target is blurred.
+                if (stateRef.current.observer) {
+                    stateRef.current.observer.disconnect();
+                    stateRef.current.observer = null;
+                }
+            };
+            target.addEventListener('focusout', onBlurHandler, {
+                once: true
+            });
+            stateRef.current.observer = new MutationObserver(()=>{
+                if (stateRef.current.isFocused && target.disabled) {
+                    var _stateRef_current_observer;
+                    (_stateRef_current_observer = stateRef.current.observer) === null || _stateRef_current_observer === void 0 ? void 0 : _stateRef_current_observer.disconnect();
+                    let relatedTargetEl = target === document.activeElement ? null : document.activeElement;
+                    target.dispatchEvent(new FocusEvent('blur', {
+                        relatedTarget: relatedTargetEl
+                    }));
+                    target.dispatchEvent(new FocusEvent('focusout', {
+                        bubbles: true,
+                        relatedTarget: relatedTargetEl
+                    }));
+                }
+            });
+            stateRef.current.observer.observe(target, {
+                attributes: true,
+                attributeFilter: [
+                    'disabled'
+                ]
+            });
+        }
+    }, [
+        dispatchBlur
+    ]);
+}
+let $8a9cb279dc87e130$export$fda7da73ab5d4c48 = false;
+function $8a9cb279dc87e130$export$cabe61c495ee3649(target) {
+    // The browser will focus the nearest focusable ancestor of our target.
+    while(target && !(0, $6dfIe$isFocusable)(target))target = target.parentElement;
+    let window = (0, $6dfIe$getOwnerWindow)(target);
+    let activeElement = window.document.activeElement;
+    if (!activeElement || activeElement === target) return;
+    $8a9cb279dc87e130$export$fda7da73ab5d4c48 = true;
+    let isRefocusing = false;
+    let onBlur = (e)=>{
+        if (e.target === activeElement || isRefocusing) e.stopImmediatePropagation();
+    };
+    let onFocusOut = (e)=>{
+        if (e.target === activeElement || isRefocusing) {
+            e.stopImmediatePropagation();
+            // If there was no focusable ancestor, we don't expect a focus event.
+            // Re-focus the original active element here.
+            if (!target && !isRefocusing) {
+                isRefocusing = true;
+                (0, $6dfIe$focusWithoutScrolling)(activeElement);
+                cleanup();
+            }
+        }
+    };
+    let onFocus = (e)=>{
+        if (e.target === target || isRefocusing) e.stopImmediatePropagation();
+    };
+    let onFocusIn = (e)=>{
+        if (e.target === target || isRefocusing) {
+            e.stopImmediatePropagation();
+            if (!isRefocusing) {
+                isRefocusing = true;
+                (0, $6dfIe$focusWithoutScrolling)(activeElement);
+                cleanup();
+            }
+        }
+    };
+    window.addEventListener('blur', onBlur, true);
+    window.addEventListener('focusout', onFocusOut, true);
+    window.addEventListener('focusin', onFocusIn, true);
+    window.addEventListener('focus', onFocus, true);
+    let cleanup = ()=>{
+        cancelAnimationFrame(raf);
+        window.removeEventListener('blur', onBlur, true);
+        window.removeEventListener('focusout', onFocusOut, true);
+        window.removeEventListener('focusin', onFocusIn, true);
+        window.removeEventListener('focus', onFocus, true);
+        $8a9cb279dc87e130$export$fda7da73ab5d4c48 = false;
+        isRefocusing = false;
+    };
+    let raf = requestAnimationFrame(cleanup);
+    return cleanup;
+}
+
+
+export {$8a9cb279dc87e130$export$525bc4921d56d4a as createSyntheticEvent, $8a9cb279dc87e130$export$c2b7abe5d61ec696 as setEventTarget, $8a9cb279dc87e130$export$715c682d09d639cc as useSyntheticBlurEvent, $8a9cb279dc87e130$export$fda7da73ab5d4c48 as ignoreFocusEvent, $8a9cb279dc87e130$export$cabe61c495ee3649 as preventFocus};
+//# sourceMappingURL=utils.module.js.map