react-stately 3.47.0 → 3.49.0

package/dist/types/src/tokenfield/TokenFieldValue.d.ts

@@ -0,0 +1,71 @@
+export type TokenFieldSegment<T = any> = TextSegment | TokenSegment<T>;
+export interface TextSegment {
+    type: 'text';
+    text: string;
+}
+export interface TokenSegment<T = any> {
+    type: 'token';
+    text: string;
+    /** An arbitrary value associated with the token. */
+    value?: T;
+}
+export interface Position {
+    /** Index of the segment in the list. */
+    index: number;
+    /** Text offset within the segment in UTF-16 code units. */
+    offset: number;
+}
+declare enum Direction {
+    Forward = 1,
+    Backward = -1
+}
+export interface TokenFieldValueOptions {
+    caretPosition?: Position | null;
+}
+/**
+ * A list of segments containing editable text and non-editable tokens.
+ */
+export declare class TokenFieldValue<T = any> {
+    static readonly Direction: typeof Direction;
+    /** The text and token segments in the list. */
+    readonly segments: readonly TokenFieldSegment<T>[];
+    /** The caret position. */
+    caretPosition: Position;
+    private previous;
+    private next;
+    private isCoalescing;
+    /** Create a new list with the given segments. */
+    constructor(tokens: readonly TokenFieldSegment<T>[], options?: TokenFieldValueOptions);
+    protected createFieldValue(segments: readonly TokenFieldSegment<T>[]): this;
+    /** Create a new list with the caret position set to the given position. */
+    withCaretPosition(caretPosition: Position): this;
+    private splitSegment;
+    private createTextSegment;
+    protected tokenize(text: string): TokenFieldSegment<T>[];
+    private clampPosition;
+    /** Replace the text between two positions with new text. */
+    replaceRange(start: Position, end: Position, text: string, coalesce?: boolean): this;
+    /** Replace the text between two positions with new segments. */
+    replaceRangeWithSegments(start: Position, end: Position, insert: TokenFieldSegment<T>[], coalesce?: boolean): this;
+    /** Find the boundary before or after a position using an Intl.Segmenter. */
+    findBoundaryWithSegmenter(position: Position, segmenter: Intl.Segmenter, direction: Direction): Position | null;
+    /** Find a line boundary before or after a position. */
+    findLineBoundary(position: Position, direction: Direction): Position | null;
+    /** Find a string or regular expression match before or after a position. */
+    findText(position: Position, direction: Direction, search: string | RegExp): Position | null;
+    /** Delete text at a position using a segmenter. */
+    delete(position: Position, segmenter: Intl.Segmenter, direction: Direction, coalesce?: boolean): this;
+    /** Delete text to the next or previous line break. */
+    deleteLine(position: Position, direction: Direction, coalesce?: boolean): this;
+    /** Create a new list containing a subset of the segments. */
+    slice(start: Position, end: Position): this;
+    /** Convert the list to a string. */
+    toString(): string;
+    /** Returns the previous list in the undo history. */
+    undo(): this;
+    /** Returns the next list in the redo history. */
+    redo(): this;
+    /** End coalescing undo/redo history. */
+    endCoalescing(): void;
+}
+export {};

package/dist/types/src/tokenfield/useTokenFieldState.d.ts

@@ -0,0 +1,19 @@
+import { TokenFieldValue } from './TokenFieldValue';
+import { ValueBase } from '@react-types/shared';
+export interface TokenFieldProps<T extends TokenFieldValue = TokenFieldValue> extends ValueBase<T> {
+}
+export interface TokenFieldState<T extends TokenFieldValue = TokenFieldValue> {
+    /** The current value of the token field. */
+    value: T;
+    /** Sets the value of the token field. */
+    setValue: (fn: T | ((value: T) => T)) => void;
+    /** Whether the token field is composing. */
+    isComposing: boolean;
+    /** Sets the composing state of the token field. */
+    setComposing: (isComposing: boolean) => void;
+}
+/**
+ * Provides state management for a token field. Tracks the field value and the
+ * composition state.
+ */
+export declare function useTokenFieldState<T extends TokenFieldValue = TokenFieldValue>(props: TokenFieldProps<T>): TokenFieldState<T>;

package/dist/types/src/tooltip/useTooltipTriggerState.d.ts

@@ -34,6 +34,11 @@ export interface TooltipTriggerProps extends OverlayTriggerProps {
 export interface TooltipTriggerState {
     /** Whether the tooltip is currently showing. */
     isOpen: boolean;
+    /**
+     * Whether the tooltip is being shown or hidden without an animation. This is true while the
+     * global warmup timer is active, i.e. when quickly moving between tooltips.
+     */
+    shouldSkipAnimation: boolean;
     /**
      * Shows the tooltip. By default, the tooltip becomes visible after a delay
      * depending on a global warmup timer. The `immediate` option shows the

package/dist/types/src/virtualizer/ScrollAnchor.d.ts

@@ -0,0 +1,81 @@
+import { Key } from '@react-types/shared';
+import { LayoutInfo } from './LayoutInfo';
+import { Rect, RectCorner } from './Rect';
+import { Size } from './Size';
+export type ScrollAnchorAxis = 'x' | 'y';
+export type ScrollAnchorEdge = 'start' | 'end';
+export interface ScrollAnchor {
+    key: Key;
+    corner: RectCorner;
+    offset: number;
+}
+export interface ScrollAnchorInfo {
+    /** Which edge of the content the viewport should stay anchored to. */
+    edge: 'start' | 'end';
+    /** Which axis `edge` refers to — 'y' for vertical lists, 'x' for horizontal. */
+    axis: 'x' | 'y';
+    /** Distance (px) from `edge` within which the viewport is considered "following" it. */
+    threshold: number;
+    /**
+     * Optional classifier excluding structural/ephemeral layout infos (e.g. loaders) from being
+     * selected as the anchor. Defaults to allowing any layoutInfo.
+     */
+    isAnchorable?: (layoutInfo: LayoutInfo) => boolean;
+}
+/**
+ * Given a previously-captured anchor, computes the new viewport coordinate (along `axis`) needed
+ * to keep it at the same offset from the viewport's start.
+ */
+export declare function computeScrollAnchorTarget(anchor: ScrollAnchor, axis: ScrollAnchorAxis, getLayoutInfo: (key: Key) => LayoutInfo | null, visibleRect: Rect, contentSize: Size): number | null;
+/**
+ * Picks the item to anchor scroll to: the one nearest the top of the viewport when
+ * anchoring to 'end', or nearest the bottom when anchoring to 'start'. Callers can
+ * exclude certain items (like loaders) with `isAnchorable`.
+ */
+export declare function captureScrollAnchor(edge: ScrollAnchorEdge, axis: ScrollAnchorAxis, visibleRect: Rect, visibleLayoutInfos: Iterable<[Key, LayoutInfo]>, isAnchorable?: (layoutInfo: LayoutInfo) => boolean): ScrollAnchor | null;
+/** Returns the viewport coordinate (along `axis`) that pins the viewport to `edge` of the content. */
+export declare function getEdgeSnapTarget(edge: ScrollAnchorEdge, axis: ScrollAnchorAxis, contentSize: Size, previousVisibleRect: Rect): number;
+/**
+ * Whether the viewport is currently within `threshold` px of the anchored edge — used by
+ * Virtualizer to compute wasNearAnchorEdge generically, without any layout-specific state.
+ */
+export declare function isNearEdge(visibleRect: Rect, contentSize: Size, edge: ScrollAnchorEdge, axis: ScrollAnchorAxis, threshold: number): boolean;
+/**
+ * Works out the new scroll position after content changes. Tries to keep the anchor
+ * item where it was. If that doesn't apply, sticks the view to the edge instead, but
+ * only if the user was already near the edge and didn't just scroll away on their own.
+ */
+export declare function resolveScrollAdjustment(edge: ScrollAnchorEdge, axis: ScrollAnchorAxis, anchor: ScrollAnchor | null, wasNearAnchorEdge: boolean, isScrolling: boolean, itemSizeChanged: boolean, contentSizeDelta: number, getLayoutInfo: (key: Key) => LayoutInfo | null, previousVisibleRect: Rect, contentSize: Size): Rect | null;
+export interface ResolveAfterLayoutOptions {
+    anchorInfo: ScrollAnchorInfo | null;
+    /** The anchor captured by `captureBeforeLayout` before this pass's `layout.update()` ran. */
+    anchor: ScrollAnchor | null;
+    /** The full post-layout visible layout infos, i.e. `virtualizer.getVisibleLayoutInfos()`. */
+    postLayoutInfos: Map<Key, LayoutInfo>;
+    previousVisibleRect: Rect;
+    previousContentSize: Size;
+    contentSize: Size;
+    itemSizeChanged: boolean;
+    isScrolling: boolean;
+    getLayoutInfo: (key: Key) => LayoutInfo | null;
+}
+/**
+ * Tracks the cross-pass state needed to keep the viewport anchored to a layout's edge across
+ * relayouts.
+ */
+export declare class ScrollAnchorTracker {
+    private hasSnappedToEdge;
+    private hadEstimatedVisibleItems;
+    private wasNearAnchorEdge;
+    /** Resets all tracked state, e.g. when the virtualizer's layout instance changes. */
+    reset(): void;
+    /**
+     * Captures the anchor from pre-layout view positions.
+     */
+    captureBeforeLayout(anchorInfo: ScrollAnchorInfo | null, preLayoutInfos: Iterable<[Key, LayoutInfo]>, visibleRect: Rect): ScrollAnchor | null;
+    /**
+     * Runs the full post-layout decision: updates the tracked state for the next pass, and
+     * returns the resolved scroll target, or null if nothing should change.
+     */
+    resolveAfterLayout(options: ResolveAfterLayoutOptions): Rect | null;
+}

package/dist/types/src/virtualizer/Virtualizer.d.ts

@@ -52,6 +52,7 @@ export declare class Virtualizer<T extends object, V> {
     private _isScrolling;
     private _invalidationContext;
     private _overscanManager;
+    private _scrollAnchor;
     constructor(options: VirtualizerOptions<T, V>);
     /** Returns whether the given key, or an ancestor, is persisted. */
     isPersistedKey(key: Key): boolean;

package/dist/types/src/virtualizer/types.d.ts

@@ -6,6 +6,8 @@ export interface InvalidationContext<O = any> {
     contentChanged?: boolean;
     offsetChanged?: boolean;
     sizeChanged?: boolean;
+    widthChanged?: boolean;
+    heightChanged?: boolean;
     itemSizeChanged?: boolean;
     layoutOptionsChanged?: boolean;
     layoutOptions?: O;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-stately",
-  "version": "3.47.0",
+  "version": "3.49.0",
   "description": "Spectrum UI components in React",
   "license": "Apache-2.0",
   "main": "./dist/exports/index.cjs",
@@ -37,10 +37,10 @@
     "url": "https://github.com/adobe/react-spectrum"
   },
   "dependencies": {
-    "@internationalized/date": "^3.12.2",
+    "@internationalized/date": "^3.12.3",
     "@internationalized/number": "^3.6.7",
-    "@internationalized/string": "^3.2.9",
-    "@react-types/shared": "^3.35.0",
+    "@internationalized/string": "^3.2.10",
+    "@react-types/shared": "^3.36.1",
     "@swc/helpers": "^0.5.0",
     "use-sync-external-store": "^1.6.0"
   },
@@ -94,5 +94,5 @@
       }
     }
   },
-  "gitHead": "3577a20859b9585a000010c720f6ee39c1c588cc"
+  "gitHead": "5ecb3333001313e83898cd07644227897e3bae1f"
 }

package/useTokenFieldState/package.json

@@ -0,0 +1,5 @@
+{
+  "main": "../dist/exports/useTokenFieldState.cjs",
+  "module": "../dist/exports/useTokenFieldState.js",
+  "types": "../dist/types/exports/useTokenFieldState.d.ts"
+}