@react-aria/utils 3.33.0 → 3.34.0

package/src/shadowdom/ShadowTreeWalker.ts

@@ -1,319 +0,0 @@
-// https://github.com/microsoft/tabster/blob/a89fc5d7e332d48f68d03b1ca6e344489d1c3898/src/Shadowdomize/ShadowTreeWalker.ts
-
-import {nodeContains} from './DOMFunctions';
-import {shadowDOM} from '@react-stately/flags';
-
-export class ShadowTreeWalker implements TreeWalker {
-  public readonly filter: NodeFilter | null;
-  public readonly root: Node;
-  public readonly whatToShow: number;
-
-  private _doc: Document;
-  private _walkerStack: Array<TreeWalker> = [];
-  private _currentNode: Node;
-  private _currentSetFor: Set<TreeWalker> = new Set();
-
-  constructor(
-      doc: Document,
-      root: Node,
-      whatToShow?: number,
-      filter?: NodeFilter | null
-    ) {
-    this._doc = doc;
-    this.root = root;
-    this.filter = filter ?? null;
-    this.whatToShow = whatToShow ?? NodeFilter.SHOW_ALL;
-    this._currentNode = root;
-
-    this._walkerStack.unshift(
-      doc.createTreeWalker(root, whatToShow, this._acceptNode)
-    );
-
-    const shadowRoot = (root as Element).shadowRoot;
-
-    if (shadowRoot) {
-      const walker = this._doc.createTreeWalker(
-        shadowRoot,
-        this.whatToShow,
-        {acceptNode: this._acceptNode}
-      );
-
-      this._walkerStack.unshift(walker);
-    }
-  }
-
-  private _acceptNode = (node: Node): number => {
-    if (node.nodeType === Node.ELEMENT_NODE) {
-      const shadowRoot = (node as Element).shadowRoot;
-
-      if (shadowRoot) {
-        const walker = this._doc.createTreeWalker(
-          shadowRoot,
-          this.whatToShow,
-          {acceptNode: this._acceptNode}
-        );
-
-        this._walkerStack.unshift(walker);
-
-        return NodeFilter.FILTER_ACCEPT;
-      } else {
-        if (typeof this.filter === 'function') {
-          return this.filter(node);
-        } else if (this.filter?.acceptNode) {
-          return this.filter.acceptNode(node);
-        } else if (this.filter === null) {
-          return NodeFilter.FILTER_ACCEPT;
-        }
-      }
-    }
-
-    return NodeFilter.FILTER_SKIP;
-  };
-
-  public get currentNode(): Node {
-    return this._currentNode;
-  }
-
-  public set currentNode(node: Node) {
-    if (!nodeContains(this.root, node)) {
-      throw new Error(
-        'Cannot set currentNode to a node that is not contained by the root node.'
-      );
-    }
-
-    const walkers: TreeWalker[] = [];
-    let curNode: Node | null | undefined = node;
-    let currentWalkerCurrentNode = node;
-
-    this._currentNode = node;
-
-    while (curNode && curNode !== this.root) {
-      if (curNode.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
-        const shadowRoot = curNode as ShadowRoot;
-
-        const walker = this._doc.createTreeWalker(
-          shadowRoot,
-          this.whatToShow,
-          {acceptNode: this._acceptNode}
-        );
-
-        walkers.push(walker);
-
-        walker.currentNode = currentWalkerCurrentNode;
-
-        this._currentSetFor.add(walker);
-
-        curNode = currentWalkerCurrentNode = shadowRoot.host;
-      } else {
-        curNode = curNode.parentNode;
-      }
-    }
-
-    const walker = this._doc.createTreeWalker(
-      this.root,
-      this.whatToShow,
-      {acceptNode: this._acceptNode}
-    );
-
-    walkers.push(walker);
-
-    walker.currentNode = currentWalkerCurrentNode;
-
-    this._currentSetFor.add(walker);
-
-    this._walkerStack = walkers;
-  }
-
-  public get doc(): Document {
-    return this._doc;
-  }
-
-  public firstChild(): Node | null {
-    let currentNode = this.currentNode;
-    let newNode = this.nextNode();
-    if (!nodeContains(currentNode, newNode)) {
-      this.currentNode = currentNode;
-      return null;
-    }
-    if (newNode) {
-      this.currentNode = newNode;
-    }
-    return newNode;
-  }
-
-  public lastChild(): Node | null {
-    let walker = this._walkerStack[0];
-    let newNode = walker.lastChild();
-    if (newNode) {
-      this.currentNode = newNode;
-    }
-    return newNode;
-  }
-
-  public nextNode(): Node | null {
-    const nextNode = this._walkerStack[0].nextNode();
-
-    if (nextNode) {
-      const shadowRoot = (nextNode as Element).shadowRoot;
-
-      if (shadowRoot) {
-        let nodeResult: number | undefined;
-
-        if (typeof this.filter === 'function') {
-          nodeResult = this.filter(nextNode);
-        } else if (this.filter?.acceptNode) {
-          nodeResult = this.filter.acceptNode(nextNode);
-        }
-
-        if (nodeResult === NodeFilter.FILTER_ACCEPT) {
-          this.currentNode = nextNode;
-          return nextNode;
-        }
-
-        // _acceptNode should have added new walker for this shadow,
-        // go in recursively.
-        let newNode = this.nextNode();
-        if (newNode) {
-          this.currentNode = newNode;
-        }
-        return newNode;
-      }
-
-      if (nextNode) {
-        this.currentNode = nextNode;
-      }
-      return nextNode;
-    } else {
-      if (this._walkerStack.length > 1) {
-        this._walkerStack.shift();
-
-        let newNode = this.nextNode();
-        if (newNode) {
-          this.currentNode = newNode;
-        }
-        return newNode;
-      } else {
-        return null;
-      }
-    }
-  }
-
-  public previousNode(): Node | null {
-    const currentWalker = this._walkerStack[0];
-
-    if (currentWalker.currentNode === currentWalker.root) {
-      if (this._currentSetFor.has(currentWalker)) {
-        this._currentSetFor.delete(currentWalker);
-
-        if (this._walkerStack.length > 1) {
-          this._walkerStack.shift();
-          let newNode = this.previousNode();
-          if (newNode) {
-            this.currentNode = newNode;
-          }
-          return newNode;
-        } else {
-          return null;
-        }
-      }
-
-      return null;
-    }
-
-    const previousNode = currentWalker.previousNode();
-
-    if (previousNode) {
-      const shadowRoot = (previousNode as Element).shadowRoot;
-
-      if (shadowRoot) {
-        let nodeResult: number | undefined;
-
-        if (typeof this.filter === 'function') {
-          nodeResult = this.filter(previousNode);
-        } else if (this.filter?.acceptNode) {
-          nodeResult = this.filter.acceptNode(previousNode);
-        }
-
-        if (nodeResult === NodeFilter.FILTER_ACCEPT) {
-          if (previousNode) {
-            this.currentNode = previousNode;
-          }
-          return previousNode;
-        }
-
-        // _acceptNode should have added new walker for this shadow,
-        // go in recursively.
-        let newNode = this.lastChild();
-        if (newNode) {
-          this.currentNode = newNode;
-        }
-        return newNode;
-      }
-
-      if (previousNode) {
-        this.currentNode = previousNode;
-      }
-      return previousNode;
-    } else {
-      if (this._walkerStack.length > 1) {
-        this._walkerStack.shift();
-
-        let newNode = this.previousNode();
-        if (newNode) {
-          this.currentNode = newNode;
-        }
-        return newNode;
-      } else {
-        return null;
-      }
-    }
-  }
-
-    /**
-     * @deprecated
-     */
-  public nextSibling(): Node | null {
-    // if (__DEV__) {
-    //     throw new Error("Method not implemented.");
-    // }
-
-    return null;
-  }
-
-    /**
-     * @deprecated
-     */
-  public previousSibling(): Node | null {
-    // if (__DEV__) {
-    //     throw new Error("Method not implemented.");
-    // }
-
-    return null;
-  }
-
-    /**
-     * @deprecated
-     */
-  public parentNode(): Node | null {
-    // if (__DEV__) {
-    //     throw new Error("Method not implemented.");
-    // }
-
-    return null;
-  }
-}
-
-/**
- * ShadowDOM safe version of document.createTreeWalker.
- */
-export function createShadowTreeWalker(
-    doc: Document,
-    root: Node,
-    whatToShow?: number,
-    filter?: NodeFilter | null
-): TreeWalker {
-  if (shadowDOM()) {
-    return new ShadowTreeWalker(doc, root, whatToShow, filter);
-  }
-  return doc.createTreeWalker(root, whatToShow, filter);
-}

package/src/useDeepMemo.ts

@@ -1,27 +0,0 @@
-/*
- * Copyright 2023 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.
- */
-
-/* eslint-disable rulesdir/pure-render */
-
-import {useRef} from 'react';
-
-export function useDeepMemo<T>(value: T, isEqual: (a: T, b: T) => boolean): T {
-  // Using a ref during render is ok here because it's only an optimization – both values are equivalent.
-  // If a render is thrown away, it'll still work the same no matter if the next render is the same or not.
-  let lastValue = useRef<T | null>(null);
-  if (value && lastValue.current && isEqual(value, lastValue.current)) {
-    value = lastValue.current;
-  }
-
-  lastValue.current = value;
-  return value;
-}

package/src/useDescription.ts

@@ -1,56 +0,0 @@
-/*
- * 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.
- */
-
-import {AriaLabelingProps} from '@react-types/shared';
-import {useLayoutEffect} from './useLayoutEffect';
-import {useState} from 'react';
-
-let descriptionId = 0;
-const descriptionNodes = new Map<string, {refCount: number, element: Element}>();
-
-export function useDescription(description?: string): AriaLabelingProps {
-  let [id, setId] = useState<string | undefined>();
-
-  useLayoutEffect(() => {
-    if (!description) {
-      return;
-    }
-
-    let desc = descriptionNodes.get(description);
-    if (!desc) {
-      let id = `react-aria-description-${descriptionId++}`;
-      setId(id);
-
-      let node = document.createElement('div');
-      node.id = id;
-      node.style.display = 'none';
-      node.textContent = description;
-      document.body.appendChild(node);
-      desc = {refCount: 0, element: node};
-      descriptionNodes.set(description, desc);
-    } else {
-      setId(desc.element.id);
-    }
-
-    desc.refCount++;
-    return () => {
-      if (desc && --desc.refCount === 0) {
-        desc.element.remove();
-        descriptionNodes.delete(description);
-      }
-    };
-  }, [description]);
-
-  return {
-    'aria-describedby': description ? id : undefined
-  };
-}

package/src/useDrag1D.ts

@@ -1,191 +0,0 @@
-/*
- * 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.
- */
-
- /* eslint-disable rulesdir/pure-render */
-
-import {getOffset} from './getOffset';
-import {nodeContains} from './shadowdom/DOMFunctions';
-import {Orientation} from '@react-types/shared';
-import React, {HTMLAttributes, MutableRefObject, useRef} from 'react';
-
-interface UseDrag1DProps {
-  containerRef: MutableRefObject<HTMLElement>,
-  reverse?: boolean,
-  orientation?: Orientation,
-  onHover?: (hovered: boolean) => void,
-  onDrag?: (dragging: boolean) => void,
-  onPositionChange?: (position: number) => void,
-  onIncrement?: () => void,
-  onDecrement?: () => void,
-  onIncrementToMax?: () => void,
-  onDecrementToMin?: () => void,
-  onCollapseToggle?: () => void
-}
-
-// Keep track of elements that we are currently handling dragging for via useDrag1D.
-// If there's an ancestor and a descendant both using useDrag1D(), and the user starts
-// dragging the descendant, we don't want useDrag1D events to fire for the ancestor.
-const draggingElements: HTMLElement[] = [];
-
-// created for splitview, this should be reusable for things like sliders/dials
-// It also handles keyboard events on the target allowing for increment/decrement by a given stepsize as well as minifying/maximizing and toggling between minified and previous size
-// It can also take a 'reverse' param to say if we should measure from the right/bottom instead of the top/left
-// It can also handle either a vertical or horizontal movement, but not both at the same time
-
-export function useDrag1D(props: UseDrag1DProps): HTMLAttributes<HTMLElement> {
-  console.warn('useDrag1D is deprecated, please use `useMove` instead https://react-spectrum.adobe.com/react-aria/useMove.html');
-  let {containerRef, reverse, orientation, onHover, onDrag, onPositionChange, onIncrement, onDecrement, onIncrementToMax, onDecrementToMin, onCollapseToggle} = props;
-  let getPosition = (e) => orientation === 'horizontal' ? e.clientX : e.clientY;
-  let getNextOffset = (e: MouseEvent) => {
-    let containerOffset = getOffset(containerRef.current, reverse, orientation);
-    let mouseOffset = getPosition(e);
-    let nextOffset = reverse ? containerOffset - mouseOffset : mouseOffset - containerOffset;
-    return nextOffset;
-  };
-  let dragging = useRef(false);
-  let prevPosition = useRef(0);
-
-  // Keep track of the current handlers in a ref so that the events can access them.
-  let handlers = useRef({onPositionChange, onDrag});
-  handlers.current.onDrag = onDrag;
-  handlers.current.onPositionChange = onPositionChange;
-
-  let onMouseDragged = (e: MouseEvent) => {
-    e.preventDefault();
-    let nextOffset = getNextOffset(e);
-    if (!dragging.current) {
-      dragging.current = true;
-      if (handlers.current.onDrag) {
-        handlers.current.onDrag(true);
-      }
-      if (handlers.current.onPositionChange) {
-        handlers.current.onPositionChange(nextOffset);
-      }
-    }
-    if (prevPosition.current === nextOffset) {
-      return;
-    }
-    prevPosition.current = nextOffset;
-    if (onPositionChange) {
-      onPositionChange(nextOffset);
-    }
-  };
-
-  let onMouseUp = (e: MouseEvent) => {
-    const target = e.target as HTMLElement;
-    dragging.current = false;
-    let nextOffset = getNextOffset(e);
-    if (handlers.current.onDrag) {
-      handlers.current.onDrag(false);
-    }
-    if (handlers.current.onPositionChange) {
-      handlers.current.onPositionChange(nextOffset);
-    }
-
-    draggingElements.splice(draggingElements.indexOf(target), 1);
-    window.removeEventListener('mouseup', onMouseUp, false);
-    window.removeEventListener('mousemove', onMouseDragged, false);
-  };
-
-  let onMouseDown = (e: React.MouseEvent<HTMLElement>) => {
-    const target = e.currentTarget;
-    // If we're already handling dragging on a descendant with useDrag1D, then
-    // we don't want to handle the drag motion on this target as well.
-    if (draggingElements.some(elt => nodeContains(target, elt))) {
-      return;
-    }
-    draggingElements.push(target);
-    window.addEventListener('mousemove', onMouseDragged, false);
-    window.addEventListener('mouseup', onMouseUp, false);
-  };
-
-  let onMouseEnter = () => {
-    if (onHover) {
-      onHover(true);
-    }
-  };
-
-  let onMouseOut = () => {
-    if (onHover) {
-      onHover(false);
-    }
-  };
-
-  let onKeyDown = (e) => {
-    switch (e.key) {
-      case 'Left':
-      case 'ArrowLeft':
-        if (orientation === 'horizontal') {
-          e.preventDefault();
-          if (onDecrement && !reverse) {
-            onDecrement();
-          } else if (onIncrement && reverse) {
-            onIncrement();
-          }
-        }
-        break;
-      case 'Up':
-      case 'ArrowUp':
-        if (orientation === 'vertical') {
-          e.preventDefault();
-          if (onDecrement && !reverse) {
-            onDecrement();
-          } else if (onIncrement && reverse) {
-            onIncrement();
-          }
-        }
-        break;
-      case 'Right':
-      case 'ArrowRight':
-        if (orientation === 'horizontal') {
-          e.preventDefault();
-          if (onIncrement && !reverse) {
-            onIncrement();
-          } else if (onDecrement && reverse) {
-            onDecrement();
-          }
-        }
-        break;
-      case 'Down':
-      case 'ArrowDown':
-        if (orientation === 'vertical') {
-          e.preventDefault();
-          if (onIncrement && !reverse) {
-            onIncrement();
-          } else if (onDecrement && reverse) {
-            onDecrement();
-          }
-        }
-        break;
-      case 'Home':
-        e.preventDefault();
-        if (onDecrementToMin) {
-          onDecrementToMin();
-        }
-        break;
-      case 'End':
-        e.preventDefault();
-        if (onIncrementToMax) {
-          onIncrementToMax();
-        }
-        break;
-      case 'Enter':
-        e.preventDefault();
-        if (onCollapseToggle) {
-          onCollapseToggle();
-        }
-        break;
-    }
-  };
-
-  return {onMouseDown, onMouseEnter, onMouseOut, onKeyDown};
-}

package/src/useEffectEvent.ts

@@ -1,30 +0,0 @@
-/*
- * Copyright 2023 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.
- */
-
-import React, {useCallback, useRef} from 'react';
-import {useLayoutEffect} from './useLayoutEffect';
-
-// Use the earliest effect type possible. useInsertionEffect runs during the mutation phase,
-// before all layout effects, but is available only in React 18 and later.
-const useEarlyEffect = React['useInsertionEffect'] ?? useLayoutEffect;
-
-export function useEffectEvent<T extends Function>(fn?: T): T {
-  const ref = useRef<T | null | undefined>(null);
-  useEarlyEffect(() => {
-    ref.current = fn;
-  }, [fn]);
-  // @ts-ignore
-  return useCallback<T>((...args) => {
-    const f = ref.current!;
-    return f?.(...args);
-  }, []);
-}

package/src/useEvent.ts

@@ -1,37 +0,0 @@
-/*
- * Copyright 2021 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.
- */
-
-import {RefObject} from '@react-types/shared';
-import {useEffect} from 'react';
-import {useEffectEvent} from './useEffectEvent';
-
-export function useEvent<K extends keyof GlobalEventHandlersEventMap>(
-  ref: RefObject<EventTarget | null>,
-  event: K | (string & {}),
-  handler?: (this: Document, ev: GlobalEventHandlersEventMap[K]) => any,
-  options?: boolean | AddEventListenerOptions
-): void {
-  let handleEvent = useEffectEvent(handler);
-  let isDisabled = handler == null;
-
-  useEffect(() => {
-    if (isDisabled || !ref.current) {
-      return;
-    }
-
-    let element = ref.current;
-    element.addEventListener(event, handleEvent as EventListener, options);
-    return () => {
-      element.removeEventListener(event, handleEvent as EventListener, options);
-    };
-  }, [ref, event, options, isDisabled]);
-}

package/src/useFormReset.ts

@@ -1,36 +0,0 @@
-/*
- * Copyright 2023 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.
- */
-
-import {RefObject} from '@react-types/shared';
-import {useEffect} from 'react';
-import {useEffectEvent} from './useEffectEvent';
-
-export function useFormReset<T>(
-  ref: RefObject<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | null> | undefined,
-  initialValue: T,
-  onReset: (value: T) => void
-): void {
-  let handleReset = useEffectEvent(() => {
-    if (onReset) {
-      onReset(initialValue);
-    }
-  });
-
-  useEffect(() => {
-    let form = ref?.current?.form;
-
-    form?.addEventListener('reset', handleReset);
-    return () => {
-      form?.removeEventListener('reset', handleReset);
-    };
-  }, [ref]);
-}