@digdir/designsystemet-react 1.0.0-next.17 → 1.0.0-next.33

package/dist/types/utilities/RovingFocus/useRovingFocus.d.ts

@@ -3,7 +3,7 @@ import type { HTMLAttributes } from 'react';
 export declare const useRovingFocus: (value: string) => {
     getOrderedItems: () => import("./RovingFocusRoot").RovingFocusElement[];
     isFocusable: boolean;
-    orientation: "vertical" | "horizontal" | "ambiguous";
+    orientation: "horizontal" | "vertical" | "ambiguous";
     getRovingProps: <T extends HTMLElement>(props: HTMLAttributes<T>) => {
         ref: (element: HTMLElement | null) => void;
         onKeyDown: (e: React.KeyboardEvent<T>) => void;
@@ -27,11 +27,11 @@ export declare const useRovingFocus: (value: string) => {
         nonce?: string | undefined;
         slot?: string | undefined;
         spellCheck?: (boolean | "true" | "false") | undefined;
-        style?: import("react").CSSProperties | undefined;
+        style?: React.CSSProperties | undefined;
         title?: string | undefined;
         translate?: "yes" | "no" | undefined;
         radioGroup?: string | undefined;
-        role?: import("react").AriaRole | undefined;
+        role?: React.AriaRole | undefined;
         about?: string | undefined;
         content?: string | undefined;
         datatype?: string | undefined;
@@ -57,6 +57,7 @@ export declare const useRovingFocus: (value: string) => {
         unselectable?: "on" | "off" | undefined;
         inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined;
         is?: string | undefined;
+        popovertarget?: string;
         "aria-activedescendant"?: string | undefined;
         "aria-atomic"?: (boolean | "true" | "false") | undefined;
         "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined;
@@ -110,168 +111,168 @@ export declare const useRovingFocus: (value: string) => {
         "aria-valuemin"?: number | undefined;
         "aria-valuenow"?: number | undefined;
         "aria-valuetext"?: string | undefined;
-        children?: import("react").ReactNode | undefined;
+        children?: React.ReactNode | undefined;
         dangerouslySetInnerHTML?: {
             __html: string | TrustedHTML;
         } | undefined;
-        onCopy?: import("react").ClipboardEventHandler<T> | undefined;
-        onCopyCapture?: import("react").ClipboardEventHandler<T> | undefined;
-        onCut?: import("react").ClipboardEventHandler<T> | undefined;
-        onCutCapture?: import("react").ClipboardEventHandler<T> | undefined;
-        onPaste?: import("react").ClipboardEventHandler<T> | undefined;
-        onPasteCapture?: import("react").ClipboardEventHandler<T> | undefined;
-        onCompositionEnd?: import("react").CompositionEventHandler<T> | undefined;
-        onCompositionEndCapture?: import("react").CompositionEventHandler<T> | undefined;
-        onCompositionStart?: import("react").CompositionEventHandler<T> | undefined;
-        onCompositionStartCapture?: import("react").CompositionEventHandler<T> | undefined;
-        onCompositionUpdate?: import("react").CompositionEventHandler<T> | undefined;
-        onCompositionUpdateCapture?: import("react").CompositionEventHandler<T> | undefined;
-        onFocusCapture?: import("react").FocusEventHandler<T> | undefined;
-        onBlur?: import("react").FocusEventHandler<T> | undefined;
-        onBlurCapture?: import("react").FocusEventHandler<T> | undefined;
-        onChange?: import("react").FormEventHandler<T> | undefined;
-        onChangeCapture?: import("react").FormEventHandler<T> | undefined;
-        onBeforeInput?: import("react").FormEventHandler<T> | undefined;
-        onBeforeInputCapture?: import("react").FormEventHandler<T> | undefined;
-        onInput?: import("react").FormEventHandler<T> | undefined;
-        onInputCapture?: import("react").FormEventHandler<T> | undefined;
-        onReset?: import("react").FormEventHandler<T> | undefined;
-        onResetCapture?: import("react").FormEventHandler<T> | undefined;
-        onSubmit?: import("react").FormEventHandler<T> | undefined;
-        onSubmitCapture?: import("react").FormEventHandler<T> | undefined;
-        onInvalid?: import("react").FormEventHandler<T> | undefined;
-        onInvalidCapture?: import("react").FormEventHandler<T> | undefined;
-        onLoad?: import("react").ReactEventHandler<T> | undefined;
-        onLoadCapture?: import("react").ReactEventHandler<T> | undefined;
-        onError?: import("react").ReactEventHandler<T> | undefined;
-        onErrorCapture?: import("react").ReactEventHandler<T> | undefined;
-        onKeyDownCapture?: import("react").KeyboardEventHandler<T> | undefined;
-        onKeyPress?: import("react").KeyboardEventHandler<T> | undefined;
-        onKeyPressCapture?: import("react").KeyboardEventHandler<T> | undefined;
-        onKeyUp?: import("react").KeyboardEventHandler<T> | undefined;
-        onKeyUpCapture?: import("react").KeyboardEventHandler<T> | undefined;
-        onAbort?: import("react").ReactEventHandler<T> | undefined;
-        onAbortCapture?: import("react").ReactEventHandler<T> | undefined;
-        onCanPlay?: import("react").ReactEventHandler<T> | undefined;
-        onCanPlayCapture?: import("react").ReactEventHandler<T> | undefined;
-        onCanPlayThrough?: import("react").ReactEventHandler<T> | undefined;
-        onCanPlayThroughCapture?: import("react").ReactEventHandler<T> | undefined;
-        onDurationChange?: import("react").ReactEventHandler<T> | undefined;
-        onDurationChangeCapture?: import("react").ReactEventHandler<T> | undefined;
-        onEmptied?: import("react").ReactEventHandler<T> | undefined;
-        onEmptiedCapture?: import("react").ReactEventHandler<T> | undefined;
-        onEncrypted?: import("react").ReactEventHandler<T> | undefined;
-        onEncryptedCapture?: import("react").ReactEventHandler<T> | undefined;
-        onEnded?: import("react").ReactEventHandler<T> | undefined;
-        onEndedCapture?: import("react").ReactEventHandler<T> | undefined;
-        onLoadedData?: import("react").ReactEventHandler<T> | undefined;
-        onLoadedDataCapture?: import("react").ReactEventHandler<T> | undefined;
-        onLoadedMetadata?: import("react").ReactEventHandler<T> | undefined;
-        onLoadedMetadataCapture?: import("react").ReactEventHandler<T> | undefined;
-        onLoadStart?: import("react").ReactEventHandler<T> | undefined;
-        onLoadStartCapture?: import("react").ReactEventHandler<T> | undefined;
-        onPause?: import("react").ReactEventHandler<T> | undefined;
-        onPauseCapture?: import("react").ReactEventHandler<T> | undefined;
-        onPlay?: import("react").ReactEventHandler<T> | undefined;
-        onPlayCapture?: import("react").ReactEventHandler<T> | undefined;
-        onPlaying?: import("react").ReactEventHandler<T> | undefined;
-        onPlayingCapture?: import("react").ReactEventHandler<T> | undefined;
-        onProgress?: import("react").ReactEventHandler<T> | undefined;
-        onProgressCapture?: import("react").ReactEventHandler<T> | undefined;
-        onRateChange?: import("react").ReactEventHandler<T> | undefined;
-        onRateChangeCapture?: import("react").ReactEventHandler<T> | undefined;
-        onResize?: import("react").ReactEventHandler<T> | undefined;
-        onResizeCapture?: import("react").ReactEventHandler<T> | undefined;
-        onSeeked?: import("react").ReactEventHandler<T> | undefined;
-        onSeekedCapture?: import("react").ReactEventHandler<T> | undefined;
-        onSeeking?: import("react").ReactEventHandler<T> | undefined;
-        onSeekingCapture?: import("react").ReactEventHandler<T> | undefined;
-        onStalled?: import("react").ReactEventHandler<T> | undefined;
-        onStalledCapture?: import("react").ReactEventHandler<T> | undefined;
-        onSuspend?: import("react").ReactEventHandler<T> | undefined;
-        onSuspendCapture?: import("react").ReactEventHandler<T> | undefined;
-        onTimeUpdate?: import("react").ReactEventHandler<T> | undefined;
-        onTimeUpdateCapture?: import("react").ReactEventHandler<T> | undefined;
-        onVolumeChange?: import("react").ReactEventHandler<T> | undefined;
-        onVolumeChangeCapture?: import("react").ReactEventHandler<T> | undefined;
-        onWaiting?: import("react").ReactEventHandler<T> | undefined;
-        onWaitingCapture?: import("react").ReactEventHandler<T> | undefined;
-        onAuxClick?: import("react").MouseEventHandler<T> | undefined;
-        onAuxClickCapture?: import("react").MouseEventHandler<T> | undefined;
-        onClick?: import("react").MouseEventHandler<T> | undefined;
-        onClickCapture?: import("react").MouseEventHandler<T> | undefined;
-        onContextMenu?: import("react").MouseEventHandler<T> | undefined;
-        onContextMenuCapture?: import("react").MouseEventHandler<T> | undefined;
-        onDoubleClick?: import("react").MouseEventHandler<T> | undefined;
-        onDoubleClickCapture?: import("react").MouseEventHandler<T> | undefined;
-        onDrag?: import("react").DragEventHandler<T> | undefined;
-        onDragCapture?: import("react").DragEventHandler<T> | undefined;
-        onDragEnd?: import("react").DragEventHandler<T> | undefined;
-        onDragEndCapture?: import("react").DragEventHandler<T> | undefined;
-        onDragEnter?: import("react").DragEventHandler<T> | undefined;
-        onDragEnterCapture?: import("react").DragEventHandler<T> | undefined;
-        onDragExit?: import("react").DragEventHandler<T> | undefined;
-        onDragExitCapture?: import("react").DragEventHandler<T> | undefined;
-        onDragLeave?: import("react").DragEventHandler<T> | undefined;
-        onDragLeaveCapture?: import("react").DragEventHandler<T> | undefined;
-        onDragOver?: import("react").DragEventHandler<T> | undefined;
-        onDragOverCapture?: import("react").DragEventHandler<T> | undefined;
-        onDragStart?: import("react").DragEventHandler<T> | undefined;
-        onDragStartCapture?: import("react").DragEventHandler<T> | undefined;
-        onDrop?: import("react").DragEventHandler<T> | undefined;
-        onDropCapture?: import("react").DragEventHandler<T> | undefined;
-        onMouseDown?: import("react").MouseEventHandler<T> | undefined;
-        onMouseDownCapture?: import("react").MouseEventHandler<T> | undefined;
-        onMouseEnter?: import("react").MouseEventHandler<T> | undefined;
-        onMouseLeave?: import("react").MouseEventHandler<T> | undefined;
-        onMouseMove?: import("react").MouseEventHandler<T> | undefined;
-        onMouseMoveCapture?: import("react").MouseEventHandler<T> | undefined;
-        onMouseOut?: import("react").MouseEventHandler<T> | undefined;
-        onMouseOutCapture?: import("react").MouseEventHandler<T> | undefined;
-        onMouseOver?: import("react").MouseEventHandler<T> | undefined;
-        onMouseOverCapture?: import("react").MouseEventHandler<T> | undefined;
-        onMouseUp?: import("react").MouseEventHandler<T> | undefined;
-        onMouseUpCapture?: import("react").MouseEventHandler<T> | undefined;
-        onSelect?: import("react").ReactEventHandler<T> | undefined;
-        onSelectCapture?: import("react").ReactEventHandler<T> | undefined;
-        onTouchCancel?: import("react").TouchEventHandler<T> | undefined;
-        onTouchCancelCapture?: import("react").TouchEventHandler<T> | undefined;
-        onTouchEnd?: import("react").TouchEventHandler<T> | undefined;
-        onTouchEndCapture?: import("react").TouchEventHandler<T> | undefined;
-        onTouchMove?: import("react").TouchEventHandler<T> | undefined;
-        onTouchMoveCapture?: import("react").TouchEventHandler<T> | undefined;
-        onTouchStart?: import("react").TouchEventHandler<T> | undefined;
-        onTouchStartCapture?: import("react").TouchEventHandler<T> | undefined;
-        onPointerDown?: import("react").PointerEventHandler<T> | undefined;
-        onPointerDownCapture?: import("react").PointerEventHandler<T> | undefined;
-        onPointerMove?: import("react").PointerEventHandler<T> | undefined;
-        onPointerMoveCapture?: import("react").PointerEventHandler<T> | undefined;
-        onPointerUp?: import("react").PointerEventHandler<T> | undefined;
-        onPointerUpCapture?: import("react").PointerEventHandler<T> | undefined;
-        onPointerCancel?: import("react").PointerEventHandler<T> | undefined;
-        onPointerCancelCapture?: import("react").PointerEventHandler<T> | undefined;
-        onPointerEnter?: import("react").PointerEventHandler<T> | undefined;
-        onPointerLeave?: import("react").PointerEventHandler<T> | undefined;
-        onPointerOver?: import("react").PointerEventHandler<T> | undefined;
-        onPointerOverCapture?: import("react").PointerEventHandler<T> | undefined;
-        onPointerOut?: import("react").PointerEventHandler<T> | undefined;
-        onPointerOutCapture?: import("react").PointerEventHandler<T> | undefined;
-        onGotPointerCapture?: import("react").PointerEventHandler<T> | undefined;
-        onGotPointerCaptureCapture?: import("react").PointerEventHandler<T> | undefined;
-        onLostPointerCapture?: import("react").PointerEventHandler<T> | undefined;
-        onLostPointerCaptureCapture?: import("react").PointerEventHandler<T> | undefined;
-        onScroll?: import("react").UIEventHandler<T> | undefined;
-        onScrollCapture?: import("react").UIEventHandler<T> | undefined;
-        onWheel?: import("react").WheelEventHandler<T> | undefined;
-        onWheelCapture?: import("react").WheelEventHandler<T> | undefined;
-        onAnimationStart?: import("react").AnimationEventHandler<T> | undefined;
-        onAnimationStartCapture?: import("react").AnimationEventHandler<T> | undefined;
-        onAnimationEnd?: import("react").AnimationEventHandler<T> | undefined;
-        onAnimationEndCapture?: import("react").AnimationEventHandler<T> | undefined;
-        onAnimationIteration?: import("react").AnimationEventHandler<T> | undefined;
-        onAnimationIterationCapture?: import("react").AnimationEventHandler<T> | undefined;
-        onTransitionEnd?: import("react").TransitionEventHandler<T> | undefined;
-        onTransitionEndCapture?: import("react").TransitionEventHandler<T> | undefined;
+        onCopy?: React.ClipboardEventHandler<T> | undefined;
+        onCopyCapture?: React.ClipboardEventHandler<T> | undefined;
+        onCut?: React.ClipboardEventHandler<T> | undefined;
+        onCutCapture?: React.ClipboardEventHandler<T> | undefined;
+        onPaste?: React.ClipboardEventHandler<T> | undefined;
+        onPasteCapture?: React.ClipboardEventHandler<T> | undefined;
+        onCompositionEnd?: React.CompositionEventHandler<T> | undefined;
+        onCompositionEndCapture?: React.CompositionEventHandler<T> | undefined;
+        onCompositionStart?: React.CompositionEventHandler<T> | undefined;
+        onCompositionStartCapture?: React.CompositionEventHandler<T> | undefined;
+        onCompositionUpdate?: React.CompositionEventHandler<T> | undefined;
+        onCompositionUpdateCapture?: React.CompositionEventHandler<T> | undefined;
+        onFocusCapture?: React.FocusEventHandler<T> | undefined;
+        onBlur?: React.FocusEventHandler<T> | undefined;
+        onBlurCapture?: React.FocusEventHandler<T> | undefined;
+        onChange?: React.FormEventHandler<T> | undefined;
+        onChangeCapture?: React.FormEventHandler<T> | undefined;
+        onBeforeInput?: React.FormEventHandler<T> | undefined;
+        onBeforeInputCapture?: React.FormEventHandler<T> | undefined;
+        onInput?: React.FormEventHandler<T> | undefined;
+        onInputCapture?: React.FormEventHandler<T> | undefined;
+        onReset?: React.FormEventHandler<T> | undefined;
+        onResetCapture?: React.FormEventHandler<T> | undefined;
+        onSubmit?: React.FormEventHandler<T> | undefined;
+        onSubmitCapture?: React.FormEventHandler<T> | undefined;
+        onInvalid?: React.FormEventHandler<T> | undefined;
+        onInvalidCapture?: React.FormEventHandler<T> | undefined;
+        onLoad?: React.ReactEventHandler<T> | undefined;
+        onLoadCapture?: React.ReactEventHandler<T> | undefined;
+        onError?: React.ReactEventHandler<T> | undefined;
+        onErrorCapture?: React.ReactEventHandler<T> | undefined;
+        onKeyDownCapture?: React.KeyboardEventHandler<T> | undefined;
+        onKeyPress?: React.KeyboardEventHandler<T> | undefined;
+        onKeyPressCapture?: React.KeyboardEventHandler<T> | undefined;
+        onKeyUp?: React.KeyboardEventHandler<T> | undefined;
+        onKeyUpCapture?: React.KeyboardEventHandler<T> | undefined;
+        onAbort?: React.ReactEventHandler<T> | undefined;
+        onAbortCapture?: React.ReactEventHandler<T> | undefined;
+        onCanPlay?: React.ReactEventHandler<T> | undefined;
+        onCanPlayCapture?: React.ReactEventHandler<T> | undefined;
+        onCanPlayThrough?: React.ReactEventHandler<T> | undefined;
+        onCanPlayThroughCapture?: React.ReactEventHandler<T> | undefined;
+        onDurationChange?: React.ReactEventHandler<T> | undefined;
+        onDurationChangeCapture?: React.ReactEventHandler<T> | undefined;
+        onEmptied?: React.ReactEventHandler<T> | undefined;
+        onEmptiedCapture?: React.ReactEventHandler<T> | undefined;
+        onEncrypted?: React.ReactEventHandler<T> | undefined;
+        onEncryptedCapture?: React.ReactEventHandler<T> | undefined;
+        onEnded?: React.ReactEventHandler<T> | undefined;
+        onEndedCapture?: React.ReactEventHandler<T> | undefined;
+        onLoadedData?: React.ReactEventHandler<T> | undefined;
+        onLoadedDataCapture?: React.ReactEventHandler<T> | undefined;
+        onLoadedMetadata?: React.ReactEventHandler<T> | undefined;
+        onLoadedMetadataCapture?: React.ReactEventHandler<T> | undefined;
+        onLoadStart?: React.ReactEventHandler<T> | undefined;
+        onLoadStartCapture?: React.ReactEventHandler<T> | undefined;
+        onPause?: React.ReactEventHandler<T> | undefined;
+        onPauseCapture?: React.ReactEventHandler<T> | undefined;
+        onPlay?: React.ReactEventHandler<T> | undefined;
+        onPlayCapture?: React.ReactEventHandler<T> | undefined;
+        onPlaying?: React.ReactEventHandler<T> | undefined;
+        onPlayingCapture?: React.ReactEventHandler<T> | undefined;
+        onProgress?: React.ReactEventHandler<T> | undefined;
+        onProgressCapture?: React.ReactEventHandler<T> | undefined;
+        onRateChange?: React.ReactEventHandler<T> | undefined;
+        onRateChangeCapture?: React.ReactEventHandler<T> | undefined;
+        onResize?: React.ReactEventHandler<T> | undefined;
+        onResizeCapture?: React.ReactEventHandler<T> | undefined;
+        onSeeked?: React.ReactEventHandler<T> | undefined;
+        onSeekedCapture?: React.ReactEventHandler<T> | undefined;
+        onSeeking?: React.ReactEventHandler<T> | undefined;
+        onSeekingCapture?: React.ReactEventHandler<T> | undefined;
+        onStalled?: React.ReactEventHandler<T> | undefined;
+        onStalledCapture?: React.ReactEventHandler<T> | undefined;
+        onSuspend?: React.ReactEventHandler<T> | undefined;
+        onSuspendCapture?: React.ReactEventHandler<T> | undefined;
+        onTimeUpdate?: React.ReactEventHandler<T> | undefined;
+        onTimeUpdateCapture?: React.ReactEventHandler<T> | undefined;
+        onVolumeChange?: React.ReactEventHandler<T> | undefined;
+        onVolumeChangeCapture?: React.ReactEventHandler<T> | undefined;
+        onWaiting?: React.ReactEventHandler<T> | undefined;
+        onWaitingCapture?: React.ReactEventHandler<T> | undefined;
+        onAuxClick?: React.MouseEventHandler<T> | undefined;
+        onAuxClickCapture?: React.MouseEventHandler<T> | undefined;
+        onClick?: React.MouseEventHandler<T> | undefined;
+        onClickCapture?: React.MouseEventHandler<T> | undefined;
+        onContextMenu?: React.MouseEventHandler<T> | undefined;
+        onContextMenuCapture?: React.MouseEventHandler<T> | undefined;
+        onDoubleClick?: React.MouseEventHandler<T> | undefined;
+        onDoubleClickCapture?: React.MouseEventHandler<T> | undefined;
+        onDrag?: React.DragEventHandler<T> | undefined;
+        onDragCapture?: React.DragEventHandler<T> | undefined;
+        onDragEnd?: React.DragEventHandler<T> | undefined;
+        onDragEndCapture?: React.DragEventHandler<T> | undefined;
+        onDragEnter?: React.DragEventHandler<T> | undefined;
+        onDragEnterCapture?: React.DragEventHandler<T> | undefined;
+        onDragExit?: React.DragEventHandler<T> | undefined;
+        onDragExitCapture?: React.DragEventHandler<T> | undefined;
+        onDragLeave?: React.DragEventHandler<T> | undefined;
+        onDragLeaveCapture?: React.DragEventHandler<T> | undefined;
+        onDragOver?: React.DragEventHandler<T> | undefined;
+        onDragOverCapture?: React.DragEventHandler<T> | undefined;
+        onDragStart?: React.DragEventHandler<T> | undefined;
+        onDragStartCapture?: React.DragEventHandler<T> | undefined;
+        onDrop?: React.DragEventHandler<T> | undefined;
+        onDropCapture?: React.DragEventHandler<T> | undefined;
+        onMouseDown?: React.MouseEventHandler<T> | undefined;
+        onMouseDownCapture?: React.MouseEventHandler<T> | undefined;
+        onMouseEnter?: React.MouseEventHandler<T> | undefined;
+        onMouseLeave?: React.MouseEventHandler<T> | undefined;
+        onMouseMove?: React.MouseEventHandler<T> | undefined;
+        onMouseMoveCapture?: React.MouseEventHandler<T> | undefined;
+        onMouseOut?: React.MouseEventHandler<T> | undefined;
+        onMouseOutCapture?: React.MouseEventHandler<T> | undefined;
+        onMouseOver?: React.MouseEventHandler<T> | undefined;
+        onMouseOverCapture?: React.MouseEventHandler<T> | undefined;
+        onMouseUp?: React.MouseEventHandler<T> | undefined;
+        onMouseUpCapture?: React.MouseEventHandler<T> | undefined;
+        onSelect?: React.ReactEventHandler<T> | undefined;
+        onSelectCapture?: React.ReactEventHandler<T> | undefined;
+        onTouchCancel?: React.TouchEventHandler<T> | undefined;
+        onTouchCancelCapture?: React.TouchEventHandler<T> | undefined;
+        onTouchEnd?: React.TouchEventHandler<T> | undefined;
+        onTouchEndCapture?: React.TouchEventHandler<T> | undefined;
+        onTouchMove?: React.TouchEventHandler<T> | undefined;
+        onTouchMoveCapture?: React.TouchEventHandler<T> | undefined;
+        onTouchStart?: React.TouchEventHandler<T> | undefined;
+        onTouchStartCapture?: React.TouchEventHandler<T> | undefined;
+        onPointerDown?: React.PointerEventHandler<T> | undefined;
+        onPointerDownCapture?: React.PointerEventHandler<T> | undefined;
+        onPointerMove?: React.PointerEventHandler<T> | undefined;
+        onPointerMoveCapture?: React.PointerEventHandler<T> | undefined;
+        onPointerUp?: React.PointerEventHandler<T> | undefined;
+        onPointerUpCapture?: React.PointerEventHandler<T> | undefined;
+        onPointerCancel?: React.PointerEventHandler<T> | undefined;
+        onPointerCancelCapture?: React.PointerEventHandler<T> | undefined;
+        onPointerEnter?: React.PointerEventHandler<T> | undefined;
+        onPointerLeave?: React.PointerEventHandler<T> | undefined;
+        onPointerOver?: React.PointerEventHandler<T> | undefined;
+        onPointerOverCapture?: React.PointerEventHandler<T> | undefined;
+        onPointerOut?: React.PointerEventHandler<T> | undefined;
+        onPointerOutCapture?: React.PointerEventHandler<T> | undefined;
+        onGotPointerCapture?: React.PointerEventHandler<T> | undefined;
+        onGotPointerCaptureCapture?: React.PointerEventHandler<T> | undefined;
+        onLostPointerCapture?: React.PointerEventHandler<T> | undefined;
+        onLostPointerCaptureCapture?: React.PointerEventHandler<T> | undefined;
+        onScroll?: React.UIEventHandler<T> | undefined;
+        onScrollCapture?: React.UIEventHandler<T> | undefined;
+        onWheel?: React.WheelEventHandler<T> | undefined;
+        onWheelCapture?: React.WheelEventHandler<T> | undefined;
+        onAnimationStart?: React.AnimationEventHandler<T> | undefined;
+        onAnimationStartCapture?: React.AnimationEventHandler<T> | undefined;
+        onAnimationEnd?: React.AnimationEventHandler<T> | undefined;
+        onAnimationEndCapture?: React.AnimationEventHandler<T> | undefined;
+        onAnimationIteration?: React.AnimationEventHandler<T> | undefined;
+        onAnimationIterationCapture?: React.AnimationEventHandler<T> | undefined;
+        onTransitionEnd?: React.TransitionEventHandler<T> | undefined;
+        onTransitionEndCapture?: React.TransitionEventHandler<T> | undefined;
     };
 };
 //# sourceMappingURL=useRovingFocus.d.ts.map

package/dist/types/utilities/RovingFocus/useRovingFocus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useRovingFocus.d.ts","sourceRoot":"","sources":["../../../../src/utilities/RovingFocus/useRovingFocus.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAK5C,wEAAwE;AACxE,eAAO,MAAM,cAAc,UAAW,MAAM;;;;qBAcvB,CAAC,SAAS,WAAW,SAAS,cAAc,CAAC,CAAC,CAAC;uBAE/C,WAAW,GAAG,IAAI;uBAOlB,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC;qBAOxB,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQrC,CAAC"}
+{"version":3,"file":"useRovingFocus.d.ts","sourceRoot":"","sources":["../../../../src/utilities/RovingFocus/useRovingFocus.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAK5C,wEAAwE;AACxE,eAAO,MAAM,cAAc,UAAW,MAAM;;;;qBAcvB,CAAC,SAAS,WAAW,SAAS,cAAc,CAAC,CAAC,CAAC;uBAE/C,WAAW,GAAG,IAAI;uBAOlB,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC;qBAOxB,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQrC,CAAC"}

package/dist/types/utilities/hooks/useSynchronizedAnimation/useSynchronizedAnimation.d.ts

@@ -10,5 +10,5 @@
  *  />
  * ```
  */
-export declare function useSynchronizedAnimation<T>(animationName: string): import("react").RefObject<T>;
+export declare function useSynchronizedAnimation<T>(animationName: string): React.RefObject<T>;
 //# sourceMappingURL=useSynchronizedAnimation.d.ts.map

package/dist/types/utilities/hooks/useSynchronizedAnimation/useSynchronizedAnimation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useSynchronizedAnimation.d.ts","sourceRoot":"","sources":["../../../../../src/utilities/hooks/useSynchronizedAnimation/useSynchronizedAnimation.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,aAAa,EAAE,MAAM,gCAuChE"}
+{"version":3,"file":"useSynchronizedAnimation.d.ts","sourceRoot":"","sources":["../../../../../src/utilities/hooks/useSynchronizedAnimation/useSynchronizedAnimation.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,aAAa,EAAE,MAAM,sBA2ChE"}

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@digdir/designsystemet-react",
-  "version": "1.0.0-next.17",
+  "version": "1.0.0-next.33",
   "description": "React components for Designsystemet",
   "author": "Designsystemet team",
-  "repository": "https://github.com/digdir/designsystemet",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/digdir/designsystemet.git"
+  },
   "homepage": "https://github.com/digdir/designsystemet/tree/main/packages/react",
   "license": "MIT",
   "types": "dist/types/index.d.ts",
@@ -32,10 +35,12 @@
     "access": "public"
   },
   "dependencies": {
-    "@floating-ui/react": "0.26.21",
+    "@floating-ui/dom": "^1.6.10",
+    "@floating-ui/react": "0.26.23",
     "@navikt/aksel-icons": "^6.14.0",
     "@radix-ui/react-slot": "^1.1.0",
-    "@tanstack/react-virtual": "^3.8.4"
+    "@tanstack/react-virtual": "^3.10.7",
+    "@u-elements/u-details": "^0.0.5"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^26.0.1",

package/dist/cjs/components/Accordion/AccordionRoot.js

@@ -1,16 +0,0 @@
-'use client';
-'use strict';
-
-var jsxRuntime = require('react/jsx-runtime');
-var lite = require('../../node_modules/clsx/dist/lite.js');
-var React = require('react');
-
-/**
- * Accordion root component, contains `Accordion.Item` components.
- */
-const AccordionRoot = React.forwardRef(({ border = false, color = 'neutral', className, ...rest }, ref) => {
-    return (jsxRuntime.jsx("div", { className: lite.clsx('ds-accordion', border && 'ds-accordion--border', color && `ds-accordion--${color}`, className), ref: ref, ...rest }));
-});
-AccordionRoot.displayName = 'AccordionRoot';
-
-exports.AccordionRoot = AccordionRoot;

package/dist/cjs/components/Box/Box.js

@@ -1,15 +0,0 @@
-'use client';
-'use strict';
-
-var jsxRuntime = require('react/jsx-runtime');
-var index = require('../../node_modules/@radix-ui/react-slot/dist/index.js');
-var lite = require('../../node_modules/clsx/dist/lite.js');
-var React = require('react');
-
-const Box = React.forwardRef(({ shadow, borderColor, borderRadius, background = 'default', children, asChild = false, className, ...rest }, ref) => {
-    const Component = asChild ? index.Slot : 'div';
-    return (jsxRuntime.jsx(Component, { ref: ref, className: lite.clsx(shadow && `ds-box--${shadow}-shadow`, borderColor && `ds-box--${borderColor}-border-color`, borderRadius && `ds-box--${borderRadius}-border-radius`, `ds-box--${background}-background`, className), ...rest, children: children }));
-});
-Box.displayName = 'Box';
-
-exports.Box = Box;

package/dist/cjs/components/List/ListHeading.js

@@ -1,28 +0,0 @@
-'use client';
-'use strict';
-
-var jsxRuntime = require('react/jsx-runtime');
-var React = require('react');
-var ListRoot = require('./ListRoot.js');
-var Heading = require('../Typography/Heading/Heading.js');
-
-const HEADING_SIZE_MAP = {
-    sm: '2xs',
-    md: 'xs',
-    lg: 'sm',
-};
-const ListHeading = React.forwardRef(({ level = 2, id, ...rest }, ref) => {
-    const { size, headingId, setHeadingId } = React.useContext(ListRoot.ListContext);
-    const randomId = React.useId();
-    const headingId_ = id ?? randomId;
-    const headingSize = React.useMemo(() => HEADING_SIZE_MAP[size], [size]);
-    React.useEffect(() => {
-        if (headingId !== headingId_) {
-            setHeadingId(headingId_);
-        }
-    }, [headingId, id, setHeadingId, headingId_]);
-    return (jsxRuntime.jsx(Heading.Heading, { ref: ref, size: headingSize, id: headingId, level: level, spacing: true, ...rest }));
-});
-ListHeading.displayName = 'ListHeading';
-
-exports.ListHeading = ListHeading;

package/dist/cjs/components/List/ListRoot.js

@@ -1,21 +0,0 @@
-'use client';
-'use strict';
-
-var jsxRuntime = require('react/jsx-runtime');
-var index = require('../../node_modules/@radix-ui/react-slot/dist/index.js');
-var React = require('react');
-
-const ListContext = React.createContext({
-    size: 'md',
-    headingId: 'heading',
-    setHeadingId: () => { },
-});
-const ListRoot = React.forwardRef(({ size = 'md', asChild, ...rest }, ref) => {
-    const [headingId, setHeadingId] = React.useState();
-    const Component = asChild ? index.Slot : 'div';
-    return (jsxRuntime.jsx(ListContext.Provider, { value: { size, headingId, setHeadingId }, children: jsxRuntime.jsx(Component, { ref: ref, ...rest }) }));
-});
-ListRoot.displayName = 'ListRoot';
-
-exports.ListContext = ListContext;
-exports.ListRoot = ListRoot;

package/dist/cjs/components/Popover/PopoverContent.js

@@ -1,105 +0,0 @@
-'use client';
-'use strict';
-
-var jsxRuntime = require('react/jsx-runtime');
-var floatingUi_react = require('../../node_modules/@floating-ui/react/dist/floating-ui.react.js');
-var lite = require('../../node_modules/clsx/dist/lite.js');
-var React = require('react');
-var PopoverRoot = require('./PopoverRoot.js');
-var floatingUi_dom = require('../../node_modules/@floating-ui/dom/dist/floating-ui.dom.js');
-var floatingUi_reactDom = require('../../node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.js');
-var useIsomorphicLayoutEffect = require('../../utilities/hooks/useIsomorphicLayoutEffect/useIsomorphicLayoutEffect.js');
-var Paragraph = require('../Typography/Paragraph/Paragraph.js');
-
-function _interopNamespaceDefault(e) {
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
-    }
-    n.default = e;
-    return Object.freeze(n);
-}
-
-var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
-
-const ARROW_HEIGHT = 7;
-const ARROW_GAP = 4;
-const ARROW_PLACEMENT = {
-    top: 'bottom',
-    right: 'left',
-    bottom: 'top',
-    left: 'right',
-};
-const PopoverContent = React.forwardRef(({ className, children, style, id, ...rest }, ref) => {
-    const { portal, internalOpen, size, isControlled, variant, placement, setInternalOpen, onClose, onOpenChange, anchorEl, popoverId, setPopoverId, triggerId, } = React.useContext(PopoverRoot.PopoverContext);
-    const Container = portal ? floatingUi_react.FloatingPortal : React__namespace.Fragment;
-    const floatingEl = React.useRef(null);
-    const arrowRef = React.useRef(null);
-    React.useEffect(() => {
-        id && setPopoverId?.(id);
-    }, [id, setPopoverId]);
-    const { context, update, refs, floatingStyles, placement: flPlacement, middlewareData: { arrow: { x: arrowX, y: arrowY } = {}, }, } = floatingUi_react.useFloating({
-        placement,
-        open: internalOpen,
-        onOpenChange: (localOpen) => {
-            onOpenChange?.(localOpen);
-            if (!localOpen)
-                onClose?.();
-            if (!isControlled)
-                setInternalOpen(localOpen);
-        },
-        whileElementsMounted: floatingUi_dom.autoUpdate,
-        elements: {
-            reference: anchorEl ?? undefined,
-            floating: floatingEl.current,
-        },
-        middleware: [
-            floatingUi_reactDom.offset(ARROW_HEIGHT + ARROW_GAP),
-            floatingUi_reactDom.flip({
-                fallbackAxisSideDirection: 'start',
-            }),
-            floatingUi_reactDom.shift(),
-            floatingUi_reactDom.arrow({
-                element: arrowRef,
-            }),
-        ],
-    });
-    const { getFloatingProps } = floatingUi_react.useInteractions([
-        floatingUi_react.useFocus(context),
-        floatingUi_react.useClick(context),
-        floatingUi_react.useDismiss(context),
-        floatingUi_react.useRole(context),
-    ]);
-    const floatingRef = floatingUi_react.useMergeRefs([refs.setFloating, ref]);
-    useIsomorphicLayoutEffect.useIsomorphicLayoutEffect(() => {
-        refs.setReference(anchorEl);
-        if (!refs.reference.current || !refs.floating.current || !internalOpen)
-            return;
-        const cleanup = floatingUi_dom.autoUpdate(refs.reference.current, refs.floating.current, update);
-        return () => cleanup();
-    }, [refs.floating, refs.reference, update, anchorEl, refs, internalOpen]);
-    const arrowPlacement = React.useMemo(() => {
-        return ARROW_PLACEMENT[flPlacement.split('-')[0]];
-    }, [flPlacement]);
-    return (jsxRuntime.jsx(jsxRuntime.Fragment, { children: internalOpen && (jsxRuntime.jsx(Container, { children: jsxRuntime.jsx(Paragraph.Paragraph, { asChild: true, size: size, children: jsxRuntime.jsxs("div", { ref: floatingEl, className: lite.clsx('ds-popover', `ds-popover--${variant}`, `ds-popover--${size}`, className), "data-placement": flPlacement, ...getFloatingProps({
-                        ref: floatingRef,
-                        tabIndex: undefined,
-                    }), style: { ...floatingStyles, ...style }, id: popoverId, "aria-labelledby": triggerId, ...rest, children: [children, jsxRuntime.jsx("div", { ref: arrowRef, className: lite.clsx('ds-popover__arrow', `ds-popover__arrow--${arrowPlacement}`), style: {
-                                height: ARROW_HEIGHT,
-                                width: ARROW_HEIGHT,
-                                ...(arrowX != null ? { left: arrowX } : {}),
-                                ...(arrowY != null ? { top: arrowY } : {}),
-                                ...(arrowPlacement ? { [arrowPlacement]: -4.5 } : {}),
-                            } })] }) }) })) }));
-});
-PopoverContent.displayName = 'Popover.Content';
-
-exports.PopoverContent = PopoverContent;