···

       
25
       
 
       
  const hasPriority = usePriority(ref, disabled);

     

       
26
       
 
       


     

       
27
       
 
       
  useLayoutEffect(() => {

     

       
28
       
-
       
    if (!ref.current || disabled) return;

     

       
0
       
 
       

     

       
29
       
 
       


     

       
30
       
 
       
    let selection = snapshotSelection(ownerRef && ownerRef.current);

     

       
31
       
 
       
    let willReceiveFocus = false;

     

       
32
       
 
       
    let focusMovesForward = true;

     

       
33
       
 
       


     

       
34
       
 
       
    function onClick(event: MouseEvent) {

     

       
35
       
-
       
      if (!ref.current || event.defaultPrevented) return;

     

       
36
       
 
       


     

       
37
       
 
       
      const target = event.target as HTMLElement | null;

     

       
38
       
-
       
      if (target && getFocusTargets(ref.current).indexOf(target) > -1) {

     

       
39
       
 
       
        selection = null;

     

       
40
       
 
       
        willReceiveFocus = true;

     

       
41
       
 
       
      }

     

       
42
       
 
       
    }

     

       
43
       
 
       


     

       
44
       
 
       
    function onFocus(event: FocusEvent) {

     

       
45
       
-
       
      if (!ref.current || event.defaultPrevented) return;

     

       
46
       
 
       


     

       
47
       
 
       
      const active = document.activeElement as HTMLElement;

     

       
48
       
 
       
      const owner =

     
···

       
65
       
 
       
        !contains(ref.current, relatedTarget)

     

       
66
       
 
       
      ) {

     

       
67
       
 
       
        // Get the next focus target of the container

     

       
68
       
-
       
        const focusTarget = getNextFocusTarget(ref.current, !focusMovesForward);

     

       
69
       
 
       
        if (focusTarget) {

     

       
70
       
 
       
          focusMovesForward = true;

     

       
71
       
 
       
          event.preventDefault();

     
···

       
75
       
 
       
    }

     

       
76
       
 
       


     

       
77
       
 
       
    function onKey(event: KeyboardEvent) {

     

       
78
       
-
       
      if (!ref.current || event.defaultPrevented || event.isComposing) return;

     

       
79
       
 
       


     

       
80
       
 
       
      // Mark whether focus is moving forward for the `onFocus` handler

     

       
81
       
 
       
      if (event.code === 'Tab') {

     
···

       
87
       
 
       
      const active = document.activeElement as HTMLElement;

     

       
88
       
 
       
      const owner =

     

       
89
       
 
       
        (ownerRef && ownerRef.current) || (selection && selection.element);

     

       
90
       
-
       
      const focusTargets = getFocusTargets(ref.current);

     

       
91
       
 
       


     

       
92
       
 
       
      if (

     

       
93
       
 
       
        !focusTargets.length ||

     
···

       
97
       
 
       
        return;

     

       
98
       
 
       
      } else if (event.code === 'Tab') {

     

       
99
       
 
       
        // Skip over the listbox via the parent if we press tab

     

       
100
       
-
       
        const currentTarget = contains(owner, active) ? owner! : ref.current;

     

       
101
       
 
       
        const focusTarget = getNextFocusTarget(currentTarget, event.shiftKey);

     

       
102
       
 
       
        if (focusTarget) {

     

       
103
       
 
       
          event.preventDefault();

     
···

       
152
       
 
       
        event.code === 'Enter'

     

       
153
       
 
       
      ) {

     

       
154
       
 
       
        // Move focus to first target when Enter is pressed

     

       
155
       
-
       
        const newTarget = getFirstFocusTarget(ref.current);

     

       
156
       
 
       
        if (newTarget) {

     

       
157
       
 
       
          willReceiveFocus = true;

     

       
158
       
 
       
          newTarget.focus();

     
···

       
169
       
 
       
      }

     

       
170
       
 
       
    }

     

       
171
       
 
       


     

       
172
       
-
       
    ref.current.addEventListener('mousedown', onClick, true);

     

       
173
       
 
       
    document.body.addEventListener('focusin', onFocus);

     

       
174
       
 
       
    document.addEventListener('keydown', onKey);

     

       
175
       
 
       


     

       
176
       
 
       
    return () => {

     

       
177
       
-
       
      ref.current!.removeEventListener('mousedown', onClick);

     

       
178
       
 
       
      document.body.removeEventListener('focusin', onFocus);

     

       
179
       
 
       
      document.removeEventListener('keydown', onKey);

     

       
180
       
 
       
    };

     

       
181
       
-
       
  }, [ref.current!, disabled, hasPriority]);

     

       
182
       
 
       
}

     

···

       
25
       
 
       
  const hasPriority = usePriority(ref, disabled);

     

       
26
       
 
       


     

       
27
       
 
       
  useLayoutEffect(() => {

     

       
28
       
+
       
    const { current: element } = ref;

     

       
29
       
+
       
    if (!element || disabled) return;

     

       
30
       
 
       


     

       
31
       
 
       
    let selection = snapshotSelection(ownerRef && ownerRef.current);

     

       
32
       
 
       
    let willReceiveFocus = false;

     

       
33
       
 
       
    let focusMovesForward = true;

     

       
34
       
 
       


     

       
35
       
 
       
    function onClick(event: MouseEvent) {

     

       
36
       
+
       
      if (!element || event.defaultPrevented) return;

     

       
37
       
 
       


     

       
38
       
 
       
      const target = event.target as HTMLElement | null;

     

       
39
       
+
       
      if (target && getFocusTargets(element).indexOf(target) > -1) {

     

       
40
       
 
       
        selection = null;

     

       
41
       
 
       
        willReceiveFocus = true;

     

       
42
       
 
       
      }

     

       
43
       
 
       
    }

     

       
44
       
 
       


     

       
45
       
 
       
    function onFocus(event: FocusEvent) {

     

       
46
       
+
       
      if (!element || event.defaultPrevented) return;

     

       
47
       
 
       


     

       
48
       
 
       
      const active = document.activeElement as HTMLElement;

     

       
49
       
 
       
      const owner =

     
···

       
66
       
 
       
        !contains(ref.current, relatedTarget)

     

       
67
       
 
       
      ) {

     

       
68
       
 
       
        // Get the next focus target of the container

     

       
69
       
+
       
        const focusTarget = getNextFocusTarget(element, !focusMovesForward);

     

       
70
       
 
       
        if (focusTarget) {

     

       
71
       
 
       
          focusMovesForward = true;

     

       
72
       
 
       
          event.preventDefault();

     
···

       
76
       
 
       
    }

     

       
77
       
 
       


     

       
78
       
 
       
    function onKey(event: KeyboardEvent) {

     

       
79
       
+
       
      if (!element || event.defaultPrevented || event.isComposing) return;

     

       
80
       
 
       


     

       
81
       
 
       
      // Mark whether focus is moving forward for the `onFocus` handler

     

       
82
       
 
       
      if (event.code === 'Tab') {

     
···

       
88
       
 
       
      const active = document.activeElement as HTMLElement;

     

       
89
       
 
       
      const owner =

     

       
90
       
 
       
        (ownerRef && ownerRef.current) || (selection && selection.element);

     

       
91
       
+
       
      const focusTargets = getFocusTargets(element);

     

       
92
       
 
       


     

       
93
       
 
       
      if (

     

       
94
       
 
       
        !focusTargets.length ||

     
···

       
98
       
 
       
        return;

     

       
99
       
 
       
      } else if (event.code === 'Tab') {

     

       
100
       
 
       
        // Skip over the listbox via the parent if we press tab

     

       
101
       
+
       
        const currentTarget = contains(owner, active) ? owner! : element;

     

       
102
       
 
       
        const focusTarget = getNextFocusTarget(currentTarget, event.shiftKey);

     

       
103
       
 
       
        if (focusTarget) {

     

       
104
       
 
       
          event.preventDefault();

     
···

       
153
       
 
       
        event.code === 'Enter'

     

       
154
       
 
       
      ) {

     

       
155
       
 
       
        // Move focus to first target when Enter is pressed

     

       
156
       
+
       
        const newTarget = getFirstFocusTarget(element);

     

       
157
       
 
       
        if (newTarget) {

     

       
158
       
 
       
          willReceiveFocus = true;

     

       
159
       
 
       
          newTarget.focus();

     
···

       
170
       
 
       
      }

     

       
171
       
 
       
    }

     

       
172
       
 
       


     

       
173
       
+
       
    element.addEventListener('mousedown', onClick, true);

     

       
174
       
 
       
    document.body.addEventListener('focusin', onFocus);

     

       
175
       
 
       
    document.addEventListener('keydown', onKey);

     

       
176
       
 
       


     

       
177
       
 
       
    return () => {

     

       
178
       
+
       
      element.removeEventListener('mousedown', onClick);

     

       
179
       
 
       
      document.body.removeEventListener('focusin', onFocus);

     

       
180
       
 
       
      document.removeEventListener('keydown', onKey);

     

       
181
       
 
       
    };

     

       
182
       
+
       
  }, [ref.current, disabled, hasPriority]);

     

       
183
       
 
       
}

     

···

       
26
       
 
       
  }, [onDismiss]);

     

       
27
       
 
       


     

       
28
       
 
       
  useLayoutEffect(() => {

     

       
29
       
-
       
    if (!ref.current || disabled) return;

     

       
0
       
 
       

     

       
30
       
 
       


     

       
31
       
 
       
    function onFocusOut(event: FocusEvent) {

     

       
32
       
 
       
      if (event.defaultPrevented) return;

     

       
33
       
 
       


     

       
34
       
 
       
      const { target, relatedTarget } = event;

     

       
35
       
-
       
      if (

     

       
36
       
-
       
        contains(ref.current, target) &&

     

       
37
       
-
       
        !contains(ref.current, relatedTarget)

     

       
38
       
-
       
      ) {

     

       
39
       
 
       
        onDismissRef.current();

     

       
40
       
 
       
      }

     

       
41
       
 
       
    }

     
···

       
45
       
 
       
        // The current dialog can be dismissed by pressing escape if it either has focus

     

       
46
       
 
       
        // or it has priority

     

       
47
       
 
       
        const active = document.activeElement;

     

       
48
       
-
       
        if (hasPriority || (active && contains(ref.current, active))) {

     

       
49
       
 
       
          event.preventDefault();

     

       
50
       
 
       
          onDismissRef.current();

     

       
51
       
 
       
        }

     
···

       
54
       
 
       


     

       
55
       
 
       
    function onClick(event: MouseEvent | TouchEvent) {

     

       
56
       
 
       
      const { target } = event;

     

       
57
       
-
       
      if (contains(ref.current, target) || event.defaultPrevented) {

     

       
58
       
 
       
        return;

     

       
59
       
 
       
      }

     

       
60
       
 
       


     

       
61
       
 
       
      // The current dialog can be dismissed by pressing outside of it if it either has

     

       
62
       
 
       
      // focus or it has priority

     

       
63
       
 
       
      const active = document.activeElement;

     

       
64
       
-
       
      if (hasPriority || (active && contains(ref.current, active))) {

     

       
65
       
 
       
        event.preventDefault();

     

       
66
       
 
       
        onDismissRef.current();

     

       
67
       
 
       
      }

     
···

       
80
       
 
       
      document.removeEventListener('touchstart', onClick);

     

       
81
       
 
       
      document.removeEventListener('keydown', onKey);

     

       
82
       
 
       
    };

     

       
83
       
-
       
  }, [ref.current!, hasPriority, disabled, focusLoss]);

     

       
84
       
 
       
}

     

···

       
26
       
 
       
  }, [onDismiss]);

     

       
27
       
 
       


     

       
28
       
 
       
  useLayoutEffect(() => {

     

       
29
       
+
       
    const { current: element } = ref;

     

       
30
       
+
       
    if (!element || disabled) return;

     

       
31
       
 
       


     

       
32
       
 
       
    function onFocusOut(event: FocusEvent) {

     

       
33
       
 
       
      if (event.defaultPrevented) return;

     

       
34
       
 
       


     

       
35
       
 
       
      const { target, relatedTarget } = event;

     

       
36
       
+
       
      if (contains(element, target) && !contains(element, relatedTarget)) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
37
       
 
       
        onDismissRef.current();

     

       
38
       
 
       
      }

     

       
39
       
 
       
    }

     
···

       
43
       
 
       
        // The current dialog can be dismissed by pressing escape if it either has focus

     

       
44
       
 
       
        // or it has priority

     

       
45
       
 
       
        const active = document.activeElement;

     

       
46
       
+
       
        if (hasPriority || (active && contains(element, active))) {

     

       
47
       
 
       
          event.preventDefault();

     

       
48
       
 
       
          onDismissRef.current();

     

       
49
       
 
       
        }

     
···

       
52
       
 
       


     

       
53
       
 
       
    function onClick(event: MouseEvent | TouchEvent) {

     

       
54
       
 
       
      const { target } = event;

     

       
55
       
+
       
      if (contains(element, target) || event.defaultPrevented) {

     

       
56
       
 
       
        return;

     

       
57
       
 
       
      }

     

       
58
       
 
       


     

       
59
       
 
       
      // The current dialog can be dismissed by pressing outside of it if it either has

     

       
60
       
 
       
      // focus or it has priority

     

       
61
       
 
       
      const active = document.activeElement;

     

       
62
       
+
       
      if (hasPriority || (active && contains(element, active))) {

     

       
63
       
 
       
        event.preventDefault();

     

       
64
       
 
       
        onDismissRef.current();

     

       
65
       
 
       
      }

     
···

       
78
       
 
       
      document.removeEventListener('touchstart', onClick);

     

       
79
       
 
       
      document.removeEventListener('keydown', onKey);

     

       
80
       
 
       
    };

     

       
81
       
+
       
  }, [ref.current, hasPriority, disabled, focusLoss]);

     

       
82
       
 
       
}

     

···

       
9
       
 
       
export function useForwardedRef<T extends HTMLElement>(

     

       
10
       
 
       
  forwarded: ForwardedRef<T>

     

       
11
       
 
       
): Ref<T> {

     

       
12
       
-
       
  const ref: RefWithState<T> = useRef<T>(null);

     

       
13
       
-
       
  if (ref._forwarded !== forwarded) {

     

       
14
       
-
       
    ref._forwarded = forwarded;

     

       
15
       
-
       
    Object.defineProperty(ref, 'current', {

     

       
16
       
 
       
      enumerable: true,

     

       
17
       
 
       
      configurable: true,

     

       
18
       
 
       
      get() {

     
···

       
26
       
 
       
          this._forwarded.current = value;

     

       
27
       
 
       
        }

     

       
28
       
 
       
      },

     

       
29
       
-
       
    });

     

       
30
       
 
       
  }

     

       
31
       
-
       


     

       
32
       
-
       
  return ref;

     

       
33
       
 
       
}

     

···

       
9
       
 
       
export function useForwardedRef<T extends HTMLElement>(

     

       
10
       
 
       
  forwarded: ForwardedRef<T>

     

       
11
       
 
       
): Ref<T> {

     

       
12
       
+
       
  const ref = useRef<RefWithState<T> | null>(null);

     

       
13
       
+
       
  if (!ref.current || ref.current._forwarded !== forwarded) {

     

       
14
       
+
       
    ref.current = Object.defineProperty({ _forwarded: forwarded }, 'current', {

     

       
0
       
 
       

     

       
15
       
 
       
      enumerable: true,

     

       
16
       
 
       
      configurable: true,

     

       
17
       
 
       
      get() {

     
···

       
25
       
 
       
          this._forwarded.current = value;

     

       
26
       
 
       
        }

     

       
27
       
 
       
      },

     

       
28
       
+
       
    }) as RefWithState<T>;

     

       
29
       
 
       
  }

     

       
30
       
+
       
  return ref.current;

     

       
0
       
 
       

     

       
31
       
 
       
}

     

···

       
21
       
 
       
  const disabled = !!(options && options.disabled);

     

       
22
       
 
       


     

       
23
       
 
       
  useLayoutEffect(() => {

     

       
24
       
-
       
    if (!ref.current || disabled) return;

     

       
0
       
 
       

     

       
25
       
 
       


     

       
26
       
 
       
    let selection: RestoreSelection | null = null;

     

       
27
       
 
       


     

       
28
       
 
       
    function onFocus(event: FocusEvent) {

     

       
29
       
-
       
      if (!ref.current || event.defaultPrevented) return;

     

       
30
       
 
       


     

       
31
       
 
       
      const owner =

     

       
32
       
 
       
        (ownerRef && ownerRef.current) || (selection && selection.element);

     
···

       
35
       
 
       
        // When owner is explicitly passed we can make a snapshot early

     

       
36
       
 
       
        selection = snapshotSelection(owner);

     

       
37
       
 
       
      } else if (

     

       
38
       
-
       
        contains(ref.current, target) &&

     

       
39
       
-
       
        !contains(ref.current, relatedTarget) &&

     

       
40
       
 
       
        (!ownerRef || contains(relatedTarget, ownerRef.current))

     

       
41
       
 
       
      ) {

     

       
42
       
 
       
        // Check whether focus is about to move into the container and snapshot last focus

     

       
43
       
 
       
        selection = snapshotSelection(owner);

     

       
44
       
 
       
      } else if (

     

       
45
       
-
       
        contains(ref.current, relatedTarget) &&

     

       
46
       
-
       
        !contains(ref.current, target)

     

       
47
       
 
       
      ) {

     

       
48
       
 
       
        // Reset focus if it's lost and has left the menu

     

       
49
       
 
       
        selection = null;

     
···

       
51
       
 
       
    }

     

       
52
       
 
       


     

       
53
       
 
       
    function onKey(event: KeyboardEvent) {

     

       
54
       
-
       
      if (!ref.current || event.defaultPrevented || event.isComposing) return;

     

       
55
       
 
       


     

       
56
       
 
       
      const owner =

     

       
57
       
 
       
        (ownerRef && ownerRef.current) || (selection && selection.element);

     

       
58
       
 
       
      const active = document.activeElement as HTMLElement;

     

       
59
       
-
       
      const focusTargets = getFocusTargets(ref.current);

     

       
60
       
 
       
      if (

     

       
61
       
 
       
        !focusTargets.length ||

     

       
62
       
-
       
        (!contains(ref.current, active) && !contains(owner, active))

     

       
63
       
 
       
      ) {

     

       
64
       
 
       
        // Do nothing if container doesn't contain focus or not targets are available

     

       
65
       
 
       
        return;

     
···

       
100
       
 
       
        event.code === 'Enter'

     

       
101
       
 
       
      ) {

     

       
102
       
 
       
        // Move focus to first target when enter is pressed

     

       
103
       
-
       
        const newTarget = getFirstFocusTarget(ref.current);

     

       
104
       
 
       
        if (newTarget) newTarget.focus();

     

       
105
       
 
       
      } else if (

     

       
106
       
 
       
        owner &&

     
···

       
129
       
 
       
      document.body.removeEventListener('focusin', onFocus);

     

       
130
       
 
       
      document.removeEventListener('keydown', onKey);

     

       
131
       
 
       
    };

     

       
132
       
-
       
  }, [ref.current!, disabled]);

     

       
133
       
 
       
}

     

···

       
21
       
 
       
  const disabled = !!(options && options.disabled);

     

       
22
       
 
       


     

       
23
       
 
       
  useLayoutEffect(() => {

     

       
24
       
+
       
    const { current: element } = ref;

     

       
25
       
+
       
    if (!element || disabled) return;

     

       
26
       
 
       


     

       
27
       
 
       
    let selection: RestoreSelection | null = null;

     

       
28
       
 
       


     

       
29
       
 
       
    function onFocus(event: FocusEvent) {

     

       
30
       
+
       
      if (!element || event.defaultPrevented) return;

     

       
31
       
 
       


     

       
32
       
 
       
      const owner =

     

       
33
       
 
       
        (ownerRef && ownerRef.current) || (selection && selection.element);

     
···

       
36
       
 
       
        // When owner is explicitly passed we can make a snapshot early

     

       
37
       
 
       
        selection = snapshotSelection(owner);

     

       
38
       
 
       
      } else if (

     

       
39
       
+
       
        contains(element, target) &&

     

       
40
       
+
       
        !contains(element, relatedTarget) &&

     

       
41
       
 
       
        (!ownerRef || contains(relatedTarget, ownerRef.current))

     

       
42
       
 
       
      ) {

     

       
43
       
 
       
        // Check whether focus is about to move into the container and snapshot last focus

     

       
44
       
 
       
        selection = snapshotSelection(owner);

     

       
45
       
 
       
      } else if (

     

       
46
       
+
       
        contains(element, relatedTarget) &&

     

       
47
       
+
       
        !contains(element, target)

     

       
48
       
 
       
      ) {

     

       
49
       
 
       
        // Reset focus if it's lost and has left the menu

     

       
50
       
 
       
        selection = null;

     
···

       
52
       
 
       
    }

     

       
53
       
 
       


     

       
54
       
 
       
    function onKey(event: KeyboardEvent) {

     

       
55
       
+
       
      if (!element || event.defaultPrevented || event.isComposing) return;

     

       
56
       
 
       


     

       
57
       
 
       
      const owner =

     

       
58
       
 
       
        (ownerRef && ownerRef.current) || (selection && selection.element);

     

       
59
       
 
       
      const active = document.activeElement as HTMLElement;

     

       
60
       
+
       
      const focusTargets = getFocusTargets(element);

     

       
61
       
 
       
      if (

     

       
62
       
 
       
        !focusTargets.length ||

     

       
63
       
+
       
        (!contains(element, active) && !contains(owner, active))

     

       
64
       
 
       
      ) {

     

       
65
       
 
       
        // Do nothing if container doesn't contain focus or not targets are available

     

       
66
       
 
       
        return;

     
···

       
101
       
 
       
        event.code === 'Enter'

     

       
102
       
 
       
      ) {

     

       
103
       
 
       
        // Move focus to first target when enter is pressed

     

       
104
       
+
       
        const newTarget = getFirstFocusTarget(element);

     

       
105
       
 
       
        if (newTarget) newTarget.focus();

     

       
106
       
 
       
      } else if (

     

       
107
       
 
       
        owner &&

     
···

       
130
       
 
       
      document.body.removeEventListener('focusin', onFocus);

     

       
131
       
 
       
      document.removeEventListener('keydown', onKey);

     

       
132
       
 
       
    };

     

       
133
       
+
       
  }, [ref.current, disabled]);

     

       
134
       
 
       
}

     

···

       
29
       
 
       
  const hasPriority = usePriority(ref, disabled);

     

       
30
       
 
       


     

       
31
       
 
       
  useLayoutEffect(() => {

     

       
32
       
-
       
    if (!ref.current || !hasPriority || disabled) return;

     

       
0
       
 
       

     

       
33
       
 
       


     

       
34
       
 
       
    let selection: RestoreSelection | null = null;

     

       
35
       
-
       
    if (

     

       
36
       
-
       
      !document.activeElement ||

     

       
37
       
-
       
      !contains(ref.current, document.activeElement)

     

       
38
       
-
       
    ) {

     

       
39
       
-
       
      const newTarget = getAutofocusTarget(ref.current);

     

       
40
       
-
       
      selection = snapshotSelection(ref.current);

     

       
41
       
 
       
      newTarget.focus();

     

       
42
       
 
       
    }

     

       
43
       
 
       


     

       
44
       
 
       
    function onBlur(event: FocusEvent) {

     

       
45
       
-
       
      const parent = ref.current;

     

       
46
       
-
       
      if (!parent || event.defaultPrevented) return;

     

       
47
       
 
       


     

       
48
       
 
       
      if (

     

       
49
       
-
       
        contains(parent, event.target) &&

     

       
50
       
-
       
        !contains(parent, event.relatedTarget)

     

       
51
       
 
       
      ) {

     

       
52
       
-
       
        const target = getFirstFocusTarget(parent);

     

       
53
       
 
       
        if (target) target.focus();

     

       
54
       
 
       
      }

     

       
55
       
 
       
    }

     

       
56
       
 
       


     

       
57
       
 
       
    function onKeyDown(event: KeyboardEvent) {

     

       
58
       
-
       
      const parent = ref.current;

     

       
59
       
-
       
      if (!parent || event.defaultPrevented) return;

     

       
60
       
 
       


     

       
61
       
 
       
      if (event.code === 'Tab') {

     

       
62
       
 
       
        const activeElement = document.activeElement as HTMLElement;

     

       
63
       
-
       
        const targets = getFocusTargets(parent);

     

       
64
       
 
       
        const index = targets.indexOf(activeElement);

     

       
65
       
 
       
        if (event.shiftKey && index === 0) {

     

       
66
       
 
       
          event.preventDefault();

     
···

       
80
       
 
       
      document.body.removeEventListener('focusout', onBlur);

     

       
81
       
 
       
      document.removeEventListener('keydown', onKeyDown);

     

       
82
       
 
       
    };

     

       
83
       
-
       
  }, [ref.current!, hasPriority, disabled]);

     

       
84
       
 
       
}

     

···

       
29
       
 
       
  const hasPriority = usePriority(ref, disabled);

     

       
30
       
 
       


     

       
31
       
 
       
  useLayoutEffect(() => {

     

       
32
       
+
       
    const { current: element } = ref;

     

       
33
       
+
       
    if (!element || !hasPriority || disabled) return;

     

       
34
       
 
       


     

       
35
       
 
       
    let selection: RestoreSelection | null = null;

     

       
36
       
+
       
    if (!document.activeElement || !contains(element, document.activeElement)) {

     

       
37
       
+
       
      const newTarget = getAutofocusTarget(element);

     

       
38
       
+
       
      selection = snapshotSelection(element);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
39
       
 
       
      newTarget.focus();

     

       
40
       
 
       
    }

     

       
41
       
 
       


     

       
42
       
 
       
    function onBlur(event: FocusEvent) {

     

       
43
       
+
       
      if (!element || event.defaultPrevented) return;

     

       
0
       
 
       

     

       
44
       
 
       


     

       
45
       
 
       
      if (

     

       
46
       
+
       
        contains(element, event.target) &&

     

       
47
       
+
       
        !contains(element, event.relatedTarget)

     

       
48
       
 
       
      ) {

     

       
49
       
+
       
        const target = getFirstFocusTarget(element);

     

       
50
       
 
       
        if (target) target.focus();

     

       
51
       
 
       
      }

     

       
52
       
 
       
    }

     

       
53
       
 
       


     

       
54
       
 
       
    function onKeyDown(event: KeyboardEvent) {

     

       
55
       
+
       
      if (!element || event.defaultPrevented) return;

     

       
0
       
 
       

     

       
56
       
 
       


     

       
57
       
 
       
      if (event.code === 'Tab') {

     

       
58
       
 
       
        const activeElement = document.activeElement as HTMLElement;

     

       
59
       
+
       
        const targets = getFocusTargets(element);

     

       
60
       
 
       
        const index = targets.indexOf(activeElement);

     

       
61
       
 
       
        if (event.shiftKey && index === 0) {

     

       
62
       
 
       
          event.preventDefault();

     
···

       
76
       
 
       
      document.body.removeEventListener('focusout', onBlur);

     

       
77
       
 
       
      document.removeEventListener('keydown', onKeyDown);

     

       
78
       
 
       
    };

     

       
79
       
+
       
  }, [ref.current, hasPriority, disabled]);

     

       
80
       
 
       
}

     

···

       
31
       
 
       
    });

     

       
32
       
 
       


     

       
33
       
 
       
    useLayoutEffect(() => {

     

       
34
       
-
       
      if (!ref.current || isDisabled) return;

     

       
35
       
-
       


     

       
36
       
-
       
      const { current } = ref;

     

       
37
       
 
       


     

       
38
       
 
       
      function onChange() {

     

       
39
       
 
       
        setHasPriority(() => priorityStack[0] === ref.current);

     

       
40
       
 
       
      }

     

       
41
       
 
       


     

       
42
       
-
       
      priorityStack.push(current);

     

       
43
       
 
       
      priorityStack.sort(sortByHierarchy);

     

       
44
       
 
       
      listeners.add(onChange);

     

       
45
       
 
       
      listeners.forEach(fn => fn());

     

       
46
       
 
       


     

       
47
       
 
       
      return () => {

     

       
48
       
-
       
        const index = priorityStack.indexOf(current);

     

       
49
       
 
       
        priorityStack.splice(index, 1);

     

       
50
       
 
       
        listeners.delete(onChange);

     

       
51
       
 
       
        listeners.forEach(fn => fn());

     

       
52
       
 
       
      };

     

       
53
       
-
       
    }, [ref.current!, isDisabled]);

     

       
54
       
 
       


     

       
55
       
 
       
    return hasPriority;

     

       
56
       
 
       
  };

     

···

       
31
       
 
       
    });

     

       
32
       
 
       


     

       
33
       
 
       
    useLayoutEffect(() => {

     

       
34
       
+
       
      const { current: element } = ref;

     

       
35
       
+
       
      if (!element || isDisabled) return;

     

       
0
       
 
       

     

       
36
       
 
       


     

       
37
       
 
       
      function onChange() {

     

       
38
       
 
       
        setHasPriority(() => priorityStack[0] === ref.current);

     

       
39
       
 
       
      }

     

       
40
       
 
       


     

       
41
       
+
       
      priorityStack.push(element);

     

       
42
       
 
       
      priorityStack.sort(sortByHierarchy);

     

       
43
       
 
       
      listeners.add(onChange);

     

       
44
       
 
       
      listeners.forEach(fn => fn());

     

       
45
       
 
       


     

       
46
       
 
       
      return () => {

     

       
47
       
+
       
        const index = priorityStack.indexOf(element);

     

       
48
       
 
       
        priorityStack.splice(index, 1);

     

       
49
       
 
       
        listeners.delete(onChange);

     

       
50
       
 
       
        listeners.forEach(fn => fn());

     

       
51
       
 
       
      };

     

       
52
       
+
       
    }, [ref.current, isDisabled]);

     

       
53
       
 
       


     

       
54
       
 
       
    return hasPriority;

     

       
55
       
 
       
  };