@testing-library/user-event - npm Package Compare versions

Comparing version 14.2.0 to 14.5.1

dist/types/clipboard/copy.d.ts

@@ -1,2 +0,2 @@
-import { Instance } from '../setup';
+import { type Instance } from '../setup';
 export declare function copy(this: Instance): Promise<DataTransfer | undefined>;

dist/types/clipboard/cut.d.ts

@@ -1,2 +0,2 @@
-import { Instance } from '../setup';
+import { type Instance } from '../setup';
 export declare function cut(this: Instance): Promise<DataTransfer | undefined>;

dist/types/clipboard/paste.d.ts

@@ -1,2 +0,2 @@
-import { Instance } from '../setup';
+import { type Instance } from '../setup';
 export declare function paste(this: Instance, clipboardData?: DataTransfer | string): Promise<void>;

dist/types/convenience/click.d.ts

@@ -1,4 +0,4 @@
-import { Instance } from '../setup';
+import { type Instance } from '../setup';
 export declare function click(this: Instance, element: Element): Promise<void>;
 export declare function dblClick(this: Instance, element: Element): Promise<void>;
 export declare function tripleClick(this: Instance, element: Element): Promise<void>;

dist/types/convenience/hover.d.ts

@@ -1,3 +0,3 @@
-import { Instance } from '../setup';
+import { type Instance } from '../setup';
 export declare function hover(this: Instance, element: Element): Promise<void>;
 export declare function unhover(this: Instance, element: Element): Promise<void>;

dist/types/convenience/tab.d.ts

@@ -1,4 +0,4 @@
-import type { Instance } from '../setup';
+import { type Instance } from '../setup';
 export declare function tab(this: Instance, { shift, }?: {
     shift?: boolean;
 }): Promise<void>;

dist/types/document/index.d.ts

@@ -1,10 +0,5 @@
-declare const isPrepared: unique symbol;
-declare global {
-    interface Node {
-        [isPrepared]?: typeof isPrepared;
-    }
-}
-export declare function prepareDocument(document: Document): void;
-export { getUIValue, setUIValue, startTrackValue, endTrackValue, clearInitialValue, } from './value';
-export { getUISelection, setUISelection } from './selection';
-export type { UISelectionRange } from './selection';
+export { getUISelection, getUIValue, setUISelection, setUIValue, clearInitialValue, } from './UI';
+export type { UISelectionRange } from './UI';
+export { getValueOrTextContent } from './getValueOrTextContent';
+export { copySelection } from './copySelection';
+export { commitValueAfterInput } from './trackValue';

dist/types/document/interceptor.d.ts

@@ -1,5 +0,5 @@
-declare type anyFunc = (...a: any[]) => any;
-declare type Params<Prop> = Prop extends anyFunc ? Parameters<Prop> : [Prop];
-declare type ImplReturn<Prop> = Prop extends anyFunc ? Parameters<Prop> : Prop;
-export declare function prepareInterceptor<ElementType extends Node, PropName extends keyof ElementType>(element: ElementType, propName: PropName, interceptorImpl: (this: ElementType, ...args: Params<ElementType[PropName]>) => {
+type anyFunc = (...a: any[]) => any;
+type Params<Prop> = Prop extends anyFunc ? Parameters<Prop> : [Prop];
+type ImplReturn<Prop> = Prop extends anyFunc ? Parameters<Prop> : Prop;
+export declare function prepareInterceptor<ElementType extends Element, PropName extends keyof ElementType>(element: ElementType, propName: PropName, interceptorImpl: (this: ElementType, ...args: Params<ElementType[PropName]>) => {
     /**
@@ -16,2 +16,5 @@ * React tracks the changes on element properties.
 }): void;
+export declare function prepareValueInterceptor(element: HTMLInputElement | HTMLTextAreaElement): void;
+export declare function prepareSelectionInterceptor(element: HTMLInputElement | HTMLTextAreaElement): void;
+export declare function prepareRangeTextInterceptor(element: HTMLInputElement | HTMLTextAreaElement): void;
 export {};

dist/types/event/behavior/registry.d.ts

@@ -1,5 +0,5 @@
-import { Config } from '../../setup';
+import { type Instance } from '../../setup';
 import { EventType } from '../types';
 export interface BehaviorPlugin<Type extends EventType> {
-    (event: DocumentEventMap[Type], target: Element, config: Config): // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+    (event: DocumentEventMap[Type], target: Element, instance: Instance): // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
     void | (() => void);
@@ -6,0 +6,0 @@ }

dist/types/event/createEvent.d.ts

@@ -1,8 +0,2 @@
-import { EventType } from './types';
-export declare type EventTypeInit<K extends EventType> = SpecificEventInit<FixedDocumentEventMap[K]>;
-interface FixedDocumentEventMap extends DocumentEventMap {
-    input: InputEvent;
-}
-declare type SpecificEventInit<E extends Event> = E extends InputEvent ? InputEventInit : E extends ClipboardEvent ? ClipboardEventInit : E extends KeyboardEvent ? KeyboardEventInit : E extends PointerEvent ? PointerEventInit : E extends MouseEvent ? MouseEventInit : E extends UIEvent ? UIEventInit : EventInit;
-export declare function createEvent<K extends EventType>(type: K, target: Element, init?: EventTypeInit<K>): DocumentEventMap[K];
-export {};
+import { type EventType, type EventTypeInit, type FixedDocumentEventMap } from './types';
+export declare function createEvent<K extends EventType>(type: K, target: Element, init?: EventTypeInit<K>): FixedDocumentEventMap[K];

dist/types/event/dispatchEvent.d.ts

@@ -1,2 +0,5 @@
-import { Config } from '../setup';
-export declare function dispatchEvent(config: Config, target: Element, event: Event, preventDefault?: boolean): boolean;
+import { type Instance } from '../setup';
+import { EventType, EventTypeInit } from './types';
+export declare function dispatchUIEvent<K extends EventType>(this: Instance, target: Element, type: K, init?: EventTypeInit<K>, preventDefault?: boolean): boolean;
+export declare function dispatchEvent(this: Instance, target: Element, event: Event, preventDefault?: boolean): boolean;
+export declare function dispatchDOMEvent<K extends EventType>(target: Element, type: K, init?: EventTypeInit<K>): void;

dist/types/event/eventMap.d.ts

@@ -0,358 +1,387 @@
+import { EventType } from './types';
 export declare const eventMap: {
-    beforeInput: {
-        EventType: string;
-        defaultInit: {
-            bubbles: boolean;
-            cancelable: boolean;
-            composed: boolean;
+    readonly click: {
+        readonly EventType: "PointerEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
         };
     };
-    input: {
-        EventType: string;
+    readonly auxclick: {
+        readonly EventType: "PointerEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
+        };
+    };
+    readonly contextmenu: {
+        readonly EventType: "PointerEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
+        };
+    };
+    readonly beforeInput: {
+        readonly EventType: "InputEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
+        };
+    };
+    readonly input: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    progress: {
-        EventType: string;
+    readonly progress: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    select: {
-        EventType: string;
+    readonly select: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    scroll: {
-        EventType: string;
+    readonly scroll: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    reset: {
-        EventType: string;
+    readonly copy: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    submit: {
-        EventType: string;
+    readonly blur: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    copy: {
-        EventType: string;
+    readonly focus: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    click: {
-        EventType: string;
+    readonly cut: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    blur: {
-        EventType: string;
+    readonly paste: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    focus: {
-        EventType: string;
+    readonly abort: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    cut: {
-        EventType: string;
+    readonly change: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    paste: {
-        EventType: string;
+    readonly drag: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    abort: {
-        EventType: string;
+    readonly drop: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    change: {
-        EventType: string;
+    readonly emptied: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    drag: {
-        EventType: string;
+    readonly ended: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    drop: {
-        EventType: string;
+    readonly error: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    emptied: {
-        EventType: string;
+    readonly invalid: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    ended: {
-        EventType: string;
+    readonly load: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    error: {
-        EventType: string;
+    readonly pause: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    invalid: {
-        EventType: string;
+    readonly play: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    load: {
-        EventType: string;
+    readonly playing: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    pause: {
-        EventType: string;
+    readonly reset: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    play: {
-        EventType: string;
+    readonly resize: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    playing: {
-        EventType: string;
+    readonly seeked: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    resize: {
-        EventType: string;
+    readonly seeking: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    seeked: {
-        EventType: string;
+    readonly stalled: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    seeking: {
-        EventType: string;
+    readonly submit: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    stalled: {
-        EventType: string;
+    readonly suspend: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    suspend: {
-        EventType: string;
+    readonly waiting: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    waiting: {
-        EventType: string;
+    readonly wheel: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    wheel: {
-        EventType: string;
+    readonly compositionEnd: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    compositionEnd: {
-        EventType: string;
+    readonly compositionStart: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    compositionStart: {
-        EventType: string;
+    readonly compositionUpdate: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    compositionUpdate: {
-        EventType: string;
+    readonly keyDown: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    keyDown: {
-        EventType: string;
+    readonly keyPress: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    keyPress: {
-        EventType: string;
+    readonly keyUp: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    keyUp: {
-        EventType: string;
+    readonly focusIn: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    focusIn: {
-        EventType: string;
+    readonly focusOut: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    focusOut: {
-        EventType: string;
+    readonly contextMenu: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    contextMenu: {
-        EventType: string;
+    readonly dblClick: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    dblClick: {
-        EventType: string;
+    readonly dragEnd: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    dragEnd: {
-        EventType: string;
+    readonly dragEnter: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    dragEnter: {
-        EventType: string;
+    readonly dragExit: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    dragExit: {
-        EventType: string;
+    readonly dragLeave: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    dragLeave: {
-        EventType: string;
+    readonly dragOver: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    dragOver: {
-        EventType: string;
+    readonly dragStart: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    dragStart: {
-        EventType: string;
+    readonly mouseDown: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    mouseDown: {
-        EventType: string;
+    readonly mouseEnter: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    mouseEnter: {
-        EventType: string;
+    readonly mouseLeave: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    mouseLeave: {
-        EventType: string;
+    readonly mouseMove: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    mouseMove: {
-        EventType: string;
+    readonly mouseOut: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    mouseOut: {
-        EventType: string;
+    readonly mouseOver: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    mouseOver: {
-        EventType: string;
+    readonly mouseUp: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    mouseUp: {
-        EventType: string;
+    readonly popState: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    popState: {
-        EventType: string;
+    readonly touchCancel: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    touchCancel: {
-        EventType: string;
+    readonly touchEnd: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    touchEnd: {
-        EventType: string;
+    readonly touchMove: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    touchMove: {
-        EventType: string;
+    readonly touchStart: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    touchStart: {
-        EventType: string;
+    readonly canPlay: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    canPlay: {
-        EventType: string;
+    readonly canPlayThrough: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    canPlayThrough: {
-        EventType: string;
+    readonly durationChange: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    durationChange: {
-        EventType: string;
+    readonly encrypted: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    encrypted: {
-        EventType: string;
+    readonly loadedData: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    loadedData: {
-        EventType: string;
+    readonly loadedMetadata: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    loadedMetadata: {
-        EventType: string;
+    readonly loadStart: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    loadStart: {
-        EventType: string;
+    readonly rateChange: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    rateChange: {
-        EventType: string;
+    readonly timeUpdate: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    timeUpdate: {
-        EventType: string;
+    readonly volumeChange: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    volumeChange: {
-        EventType: string;
+    readonly animationStart: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    animationStart: {
-        EventType: string;
+    readonly animationEnd: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    animationEnd: {
-        EventType: string;
+    readonly animationIteration: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    animationIteration: {
-        EventType: string;
+    readonly transitionCancel: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    transitionCancel: {
-        EventType: string;
+    readonly transitionEnd: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    transitionEnd: {
-        EventType: string;
+    readonly transitionRun: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    transitionRun: {
-        EventType: string;
+    readonly transitionStart: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    transitionStart: {
-        EventType: string;
+    readonly doubleClick: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    doubleClick: {
-        EventType: string;
+    readonly pointerOver: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    pointerOver: {
-        EventType: string;
+    readonly pointerEnter: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    pointerEnter: {
-        EventType: string;
+    readonly pointerDown: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    pointerDown: {
-        EventType: string;
+    readonly pointerMove: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    pointerMove: {
-        EventType: string;
+    readonly pointerUp: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    pointerUp: {
-        EventType: string;
+    readonly pointerCancel: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    pointerCancel: {
-        EventType: string;
+    readonly pointerOut: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    pointerOut: {
-        EventType: string;
+    readonly pointerLeave: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    pointerLeave: {
-        EventType: string;
+    readonly gotPointerCapture: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    gotPointerCapture: {
-        EventType: string;
+    readonly lostPointerCapture: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
-    lostPointerCapture: {
-        EventType: string;
+    readonly offline: {
+        EventType: EventInterface;
         defaultInit: EventInit;
     };
+    readonly online: {
+        EventType: EventInterface;
+        defaultInit: EventInit;
+    };
 };
@@ -362,1 +391,3 @@ export declare const eventMapKeys: {
 };
+export declare function isMouseEvent(type: EventType): boolean;
+export declare function isKeyboardEvent(type: EventType): boolean;

dist/types/event/index.d.ts

@@ -1,6 +0,7 @@
-import { Config } from '../setup';
-import { EventTypeInit } from './createEvent';
 import { EventType, PointerCoords } from './types';
 export type { EventType, PointerCoords };
-export declare function dispatchUIEvent<K extends EventType>(config: Config, target: Element, type: K, init?: EventTypeInit<K>, preventDefault?: boolean): boolean;
-export declare function bindDispatchUIEvent(config: Config): (target: Element, type: keyof DocumentEventMap, init?: InputEventInit | UIEventInit | EventInit | ClipboardEventInit | MouseEventInit | PointerEventInit | KeyboardEventInit | undefined, preventDefault?: boolean | undefined) => boolean;
+export { dispatchEvent, dispatchUIEvent, dispatchDOMEvent } from './dispatchEvent';
+export { blurElement, focusElement } from './focus';
+export { input } from './input';
+export type { SelectionRange } from './selection';
+export { isAllSelected, modifySelectionPerMouseMove, setSelectionPerMouseDown, selectAll, } from './selection';

dist/types/event/types.d.ts

@@ -1,2 +0,7 @@
-export declare type EventType = keyof DocumentEventMap;
+export type EventType = keyof DocumentEventMap;
+export type EventTypeInit<K extends EventType> = SpecificEventInit<FixedDocumentEventMap[K]>;
+export interface FixedDocumentEventMap extends DocumentEventMap {
+    input: InputEvent;
+}
+type SpecificEventInit<E extends Event> = E extends InputEvent ? InputEventInit : E extends ClipboardEvent ? ClipboardEventInit : E extends KeyboardEvent ? KeyboardEventInit : E extends PointerEvent ? PointerEventInit : E extends MouseEvent ? MouseEventInit : E extends UIEvent ? UIEventInit : EventInit;
 export interface PointerCoords {
@@ -14,1 +19,2 @@ x?: number;
 }
+export {};

dist/types/index.d.ts

 export { userEvent as default } from './setup';
-export type { keyboardKey } from './keyboard';
-export type { pointerKey } from './pointer';
-export { PointerEventsCheckLevel } from './options';
+export { userEvent } from './setup';
+export type { UserEvent } from './setup/setup';
+export type { keyboardKey } from './system/keyboard';
+export type { pointerKey } from './system/pointer';
+export { PointerEventsCheckLevel, type Options } from './options';

dist/types/keyboard/index.d.ts

@@ -1,7 +0,3 @@
-import { Instance } from '../setup';
-import { releaseAllKeys } from './keyboardAction';
-import type { keyboardState, keyboardKey } from './types';
-export { releaseAllKeys };
-export type { keyboardKey, keyboardState };
+import { type Instance } from '../setup';
 export declare function keyboard(this: Instance, text: string): Promise<void>;
-export declare function createKeyboardState(): keyboardState;
+export declare function releaseAllKeys(instance: Instance): Promise<void>;

dist/types/keyboard/keyMap.d.ts

@@ -1,2 +0,2 @@
-import { keyboardKey } from './types';
+import { keyboardKey } from '../system/keyboard';
 /**
@@ -3,0 +3,0 @@ * Mapping for a default US-104-QWERTY keyboard

dist/types/keyboard/parseKeyDef.d.ts

@@ -1,2 +0,2 @@
-import { keyboardKey } from './types';
+import { keyboardKey } from '../system/keyboard';
 /**
@@ -3,0 +3,0 @@ * Parse key defintions per `keyboardMap`

dist/types/options.d.ts

@@ -1,3 +0,3 @@
-import type { keyboardKey } from './keyboard/types';
-import type { pointerKey } from './pointer/types';
+import { type keyboardKey } from './system/keyboard';
+import { type pointerKey } from './system/pointer';
 export declare enum PointerEventsCheckLevel {
@@ -86,3 +86,3 @@ /**
     /**
-     * `userEvent.type` implys a click at the end of the element content/value.
+     * `userEvent.type` implies a click at the end of the element content/value.
      * This option allows to opt out of this feature.
@@ -94,3 +94,3 @@ *
     /**
-     * `userEvent.click` implys moving the cursor to the target element first.
+     * `userEvent.click` implies moving the cursor to the target element first.
      * This options allows to opt out of this feature.
@@ -118,9 +118,1 @@ *
 }
-/**
- * Default options applied when API is called per `userEvent.anyApi()`
- */
-export declare const defaultOptionsDirect: Required<Options>;
-/**
- * Default options applied when API is called per `userEvent().anyApi()`
- */
-export declare const defaultOptionsSetup: Required<Options>;

dist/types/pointer/index.d.ts

@@ -1,10 +0,28 @@
-import { Instance } from '../setup';
-import { PointerAction, PointerActionTarget } from './pointerAction';
-import type { pointerState, pointerKey } from './types';
-export type { pointerState, pointerKey };
-declare type PointerActionInput = string | ({
+import { type PointerCoords } from '../event';
+import { type Instance } from '../setup';
+import { type pointerKey } from '../system/pointer';
+type PointerActionInput = string | ({
     keys: string;
-} & PointerActionTarget) | PointerAction;
-export declare type PointerInput = PointerActionInput | Array<PointerActionInput>;
+} & PointerActionPosition) | PointerAction;
+export type PointerInput = PointerActionInput | Array<PointerActionInput>;
+type PointerAction = PointerPressAction | PointerMoveAction;
+type PointerActionPosition = {
+    target?: Element;
+    coords?: PointerCoords;
+    node?: Node;
+    /**
+     * If `node` is set, this is the DOM offset.
+     * Otherwise this is the `textContent`/`value` offset on the `target`.
+     */
+    offset?: number;
+};
+interface PointerPressAction extends PointerActionPosition {
+    keyDef: pointerKey;
+    releasePrevious: boolean;
+    releaseSelf: boolean;
+}
+interface PointerMoveAction extends PointerActionPosition {
+    pointerName?: string;
+}
 export declare function pointer(this: Instance, input: PointerInput): Promise<void>;
-export declare function createPointerState(document: Document): pointerState;
+export {};

dist/types/pointer/keyMap.d.ts

@@ -1,2 +0,2 @@
-import { pointerKey } from './types';
+import { pointerKey } from '../system/pointer';
 export declare const defaultKeyMap: pointerKey[];

dist/types/pointer/parseKeyDef.d.ts

@@ -1,2 +0,2 @@
-import { pointerKey } from './types';
+import { pointerKey } from '../system/pointer';
 export declare function parseKeyDef(pointerMap: pointerKey[], keys: string): {
@@ -3,0 +3,0 @@ keyDef: pointerKey;

dist/types/setup/api.d.ts

@@ -1,5 +0,23 @@
-export { click, dblClick, tripleClick, hover, unhover, tab } from '../convenience';
-export { keyboard } from '../keyboard';
-export { copy, cut, paste } from '../clipboard';
-export { pointer } from '../pointer';
-export { clear, deselectOptions, selectOptions, type, upload } from '../utility';
+import { click, dblClick, tripleClick, hover, unhover, tab } from '../convenience';
+import { keyboard } from '../keyboard';
+import { copy, cut, paste } from '../clipboard';
+import { pointer } from '../pointer';
+import { clear, deselectOptions, selectOptions, type, upload } from '../utility';
+export declare const userEventApi: {
+    click: typeof click;
+    dblClick: typeof dblClick;
+    tripleClick: typeof tripleClick;
+    hover: typeof hover;
+    unhover: typeof unhover;
+    tab: typeof tab;
+    keyboard: typeof keyboard;
+    copy: typeof copy;
+    cut: typeof cut;
+    paste: typeof paste;
+    pointer: typeof pointer;
+    clear: typeof clear;
+    deselectOptions: typeof deselectOptions;
+    selectOptions: typeof selectOptions;
+    type: typeof type;
+    upload: typeof upload;
+};

dist/types/setup/directApi.d.ts

@@ -1,19 +0,24 @@
-import type { PointerInput } from '../pointer';
-import type { UserEventApi } from '.';
-import { Config } from './config';
+import { type Options } from '../options';
+import { type PointerInput } from '../pointer';
+import { type System } from '../system';
+import { type UserEventApi } from './setup';
+export type DirectOptions = Options & {
+    keyboardState?: System;
+    pointerState?: System;
+};
 export declare function clear(element: Element): Promise<void>;
-export declare function click(element: Element, options?: Partial<Config>): Promise<void>;
-export declare function copy(options?: Partial<Config>): Promise<DataTransfer | undefined>;
-export declare function cut(options?: Partial<Config>): Promise<DataTransfer | undefined>;
-export declare function dblClick(element: Element, options?: Partial<Config>): Promise<void>;
-export declare function deselectOptions(select: Element, values: HTMLElement | HTMLElement[] | string[] | string, options?: Partial<Config>): Promise<void>;
-export declare function hover(element: Element, options?: Partial<Config>): Promise<void>;
-export declare function keyboard(text: string, options?: Partial<Config>): Promise<import("../keyboard").keyboardState>;
-export declare function pointer(input: PointerInput, options?: Partial<Config>): Promise<import("../pointer").pointerState>;
-export declare function paste(clipboardData?: DataTransfer | string, options?: Partial<Config>): Promise<void>;
-export declare function selectOptions(select: Element, values: HTMLElement | HTMLElement[] | string[] | string, options?: Partial<Config>): Promise<void>;
-export declare function tripleClick(element: Element, options?: Partial<Config>): Promise<void>;
-export declare function type(element: Element, text: string, options?: Partial<Config> & Parameters<UserEventApi['type']>[2]): Promise<void>;
-export declare function unhover(element: Element, options?: Partial<Config>): Promise<void>;
-export declare function upload(element: HTMLElement, fileOrFiles: File | File[], options?: Partial<Config>): Promise<void>;
-export declare function tab(options?: Partial<Config> & Parameters<UserEventApi['tab']>[0]): Promise<void>;
+export declare function click(element: Element, options?: DirectOptions): Promise<void>;
+export declare function copy(options?: DirectOptions): Promise<DataTransfer | undefined>;
+export declare function cut(options?: DirectOptions): Promise<DataTransfer | undefined>;
+export declare function dblClick(element: Element, options?: DirectOptions): Promise<void>;
+export declare function deselectOptions(select: Element, values: HTMLElement | HTMLElement[] | string[] | string, options?: DirectOptions): Promise<void>;
+export declare function hover(element: Element, options?: DirectOptions): Promise<void>;
+export declare function keyboard(text: string, options?: DirectOptions): Promise<System>;
+export declare function pointer(input: PointerInput, options?: DirectOptions): Promise<System>;
+export declare function paste(clipboardData?: DataTransfer | string, options?: DirectOptions): Promise<void>;
+export declare function selectOptions(select: Element, values: HTMLElement | HTMLElement[] | string[] | string, options?: DirectOptions): Promise<void>;
+export declare function tripleClick(element: Element, options?: DirectOptions): Promise<void>;
+export declare function type(element: Element, text: string, options?: DirectOptions & Parameters<UserEventApi['type']>[2]): Promise<void>;
+export declare function unhover(element: Element, options?: DirectOptions): Promise<void>;
+export declare function upload(element: HTMLElement, fileOrFiles: File | File[], options?: DirectOptions): Promise<void>;
+export declare function tab(options?: DirectOptions & Parameters<UserEventApi['tab']>[0]): Promise<void>;

dist/types/setup/index.d.ts

@@ -1,18 +0,4 @@
-import type { bindDispatchUIEvent } from '../event';
-import type * as userEventApi from './api';
-import { setupMain, setupSub } from './setup';
-import { Config, inputDeviceState } from './config';
+import { setupMain } from './setup';
 import * as directApi from './directApi';
-export type { inputDeviceState };
-export { Config };
-export declare type UserEventApi = typeof userEventApi;
-export declare type Instance = UserEventApi & {
-    [Config]: Config;
-    dispatchUIEvent: ReturnType<typeof bindDispatchUIEvent>;
-};
-export declare type UserEvent = {
-    readonly setup: (...args: Parameters<typeof setupSub>) => UserEvent;
-} & {
-    readonly [k in keyof UserEventApi]: (...args: Parameters<UserEventApi[k]>) => ReturnType<UserEventApi[k]>;
-};
+export type { Instance } from './setup';
 export declare const userEvent: {
@@ -19,0 +5,0 @@ readonly setup: typeof setupMain;

dist/types/setup/setup.d.ts

@@ -0,5 +1,21 @@
+import { dispatchEvent, dispatchUIEvent } from '../event';
 import { Options } from '../options';
-import type { Instance, UserEvent } from './index';
-import { Config } from './config';
-export declare function createConfig(options?: Partial<Config>, defaults?: Required<Options>, node?: Node): Config;
+import { System } from '../system';
+import { userEventApi } from './api';
+import { DirectOptions } from './directApi';
+export type UserEventApi = typeof userEventApi;
+export type UserEvent = {
+    readonly setup: (...args: Parameters<typeof setupSub>) => UserEvent;
+} & {
+    readonly [k in keyof UserEventApi]: (...args: Parameters<UserEventApi[k]>) => ReturnType<UserEventApi[k]>;
+};
+export type Instance = UserEventApi & {
+    config: Config;
+    dispatchEvent: OmitThisParameter<typeof dispatchEvent>;
+    dispatchUIEvent: OmitThisParameter<typeof dispatchUIEvent>;
+    system: System;
+    levelRefs: Record<number, object | undefined>;
+};
+export type Config = Required<Options>;
+export declare function createConfig(options?: Options, defaults?: Required<Options>, node?: Node): Config;
 /**
@@ -13,5 +29,9 @@ * Start a "session" with userEvent.
  */
-export declare function setupDirect(options?: Partial<Config>, node?: Node): {
-    config: Config;
+export declare function setupDirect({ keyboardState, pointerState, ...options }?: DirectOptions & {
+    keyboardState?: System;
+    pointerState?: System;
+}, // backward-compatibility
+node?: Node): {
     api: UserEvent;
+    system: System;
 };
@@ -22,1 +42,5 @@ /**
 export declare function setupSub(this: Instance, options: Options): UserEvent;
+export declare function createInstance(config: Config, system?: System): {
+    instance: Instance;
+    api: UserEvent;
+};

dist/types/utility/clear.d.ts

@@ -1,2 +0,2 @@
-import { Instance } from '../setup';
+import { type Instance } from '../setup';
 export declare function clear(this: Instance, element: Element): Promise<void>;

dist/types/utility/selectOptions.d.ts

@@ -1,3 +0,3 @@
-import { Instance } from '../setup';
+import { type Instance } from '../setup';
 export declare function selectOptions(this: Instance, select: Element, values: HTMLElement | HTMLElement[] | string[] | string): Promise<void>;
 export declare function deselectOptions(this: Instance, select: Element, values: HTMLElement | HTMLElement[] | string[] | string): Promise<void>;

dist/types/utility/type.d.ts

@@ -1,6 +0,6 @@
-import type { Instance } from '../setup';
-import { Config } from '../setup/config';
+import { type Instance } from '../setup';
+import { type Options } from '../options';
 export interface typeOptions {
-    skipClick?: Config['skipClick'];
-    skipAutoClose?: Config['skipClick'];
+    skipClick?: Options['skipClick'];
+    skipAutoClose?: Options['skipAutoClose'];
     initialSelectionStart?: number;
@@ -7,0 +7,0 @@ initialSelectionEnd?: number;

dist/types/utility/upload.d.ts

@@ -1,2 +0,2 @@
-import { Instance } from '../setup';
+import { type Instance } from '../setup';
 export interface uploadInit {
@@ -3,0 +3,0 @@ changeInit?: EventInit;

dist/types/utils/click/isClickableInput.d.ts

@@ -1,1 +0,15 @@
-export declare function isClickableInput(element: Element): boolean;
+declare enum clickableInputTypes {
+    'button' = "button",
+    'color' = "color",
+    'file' = "file",
+    'image' = "image",
+    'reset' = "reset",
+    'submit' = "submit",
+    'checkbox' = "checkbox",
+    'radio' = "radio"
+}
+export type ClickableInputOrButton = HTMLButtonElement | (HTMLInputElement & {
+    type: clickableInputTypes;
+});
+export declare function isClickableInput(element: Element): element is ClickableInputOrButton;
+export {};

dist/types/utils/dataTransfer/Clipboard.d.ts

 export declare function createClipboardItem(window: Window & typeof globalThis, ...blobs: Array<Blob | string>): ClipboardItem;
-export declare function attachClipboardStubToView(window: Window & typeof globalThis): {
+type ClipboardStubControlInstance = {
     resetClipboardStub: () => void;
     detachClipboardStub: () => void;
 };
+export declare function attachClipboardStubToView(window: Window & typeof globalThis): ClipboardStubControlInstance;
 export declare function resetClipboardStubOnView(window: Window & typeof globalThis): void;
@@ -10,1 +11,2 @@ export declare function detachClipboardStubFromView(window: Window & typeof globalThis): void;
 export declare function writeDataTransferToClipboard(document: Document, clipboardData: DataTransfer): Promise<void>;
+export {};

dist/types/utils/dataTransfer/FileList.d.ts

@@ -1,1 +0,1 @@
-export declare function createFileList(files: File[]): FileList;
+export declare function createFileList(window: Window & typeof globalThis, files: File[]): FileList;

dist/types/utils/edit/isEditable.d.ts

 import { isContentEditable } from './isContentEditable';
-declare type GuardedType<T> = T extends (x: any) => x is infer R ? R : never;
-export declare function isEditable(element: Element): element is GuardedType<typeof isContentEditable> | GuardedType<typeof isEditableInput> | (HTMLTextAreaElement & {
+type GuardedType<T> = T extends (x: any) => x is infer R ? R : never;
+export declare function isEditable(element: Element): element is GuardedType<typeof isContentEditable> | (EditableInputOrTextarea & {
     readOnly: false;
 });
-export declare enum editableInputTypes {
+declare enum editableInputTypes {
     'text' = "text",
@@ -20,7 +20,6 @@ 'date' = "date",
 }
-export declare type EditableInputType = keyof typeof editableInputTypes;
-export declare function isEditableInput(element: Element): element is HTMLInputElement & {
-    readOnly: false;
+export type EditableInputOrTextarea = HTMLTextAreaElement | (HTMLInputElement & {
     type: editableInputTypes;
-};
+});
+export declare function isEditableInputOrTextArea(element: Element): element is EditableInputOrTextarea;
 export {};

dist/types/utils/edit/maxLength.d.ts

@@ -1,1 +0,14 @@
-export declare function getSpaceUntilMaxLength(element: Element): number | undefined;
+declare enum maxLengthSupportedTypes {
+    'email' = "email",
+    'password' = "password",
+    'search' = "search",
+    'telephone' = "telephone",
+    'text' = "text",
+    'url' = "url"
+}
+type ElementWithMaxLengthSupport = HTMLTextAreaElement | (HTMLInputElement & {
+    type: maxLengthSupportedTypes;
+});
+export declare function getMaxLength(element: ElementWithMaxLengthSupport): number | undefined;
+export declare function supportsMaxLength(element: Element): element is ElementWithMaxLengthSupport;
+export {};

dist/types/utils/focus/getActiveElement.d.ts

 export declare function getActiveElement(document: Document | ShadowRoot): Element | null;
+export declare function getActiveElementOrBody(document: Document): Element;

dist/types/utils/focus/selection.d.ts

@@ -1,46 +0,8 @@
-import { UISelectionRange } from '../../document';
-import { editableInputTypes } from '../edit/isEditable';
+import { ClickableInputOrButton } from '../click/isClickableInput';
+import { EditableInputOrTextarea } from '../edit/isEditable';
 /**
- * Backward-compatible selection.
- *
- * Handles input elements and contenteditable if it only contains a single text node.
- */
-export declare function setSelectionRange(element: Element, anchorOffset: number, focusOffset: number): void;
-/**
  * Determine if the element has its own selection implementation
  * and does not interact with the Document Selection API.
  */
-export declare function hasOwnSelection(node: Node): node is HTMLTextAreaElement | (HTMLInputElement & {
-    type: editableInputTypes;
-});
-/**
- * Reset the Document Selection when moving focus into an element
- * with own selection implementation.
- */
-export declare function updateSelectionOnFocus(element: Element): void;
-/**
- * Get the range that would be overwritten by input.
- */
-export declare function getInputRange(focusNode: Node): UISelectionRange | Range | undefined;
-/**
- * Extend/shrink the selection like with Shift+Arrows or Shift+Mouse
- */
-export declare function modifySelection({ focusNode, focusOffset, }: {
-    focusNode: Node;
-    /** DOM Offset */
-    focusOffset: number;
-}): void;
-/**
- * Set the selection
- */
-export declare function setSelection({ focusNode, focusOffset, anchorNode, anchorOffset, }: {
-    anchorNode?: Node;
-    /** DOM offset */
-    anchorOffset?: number;
-    focusNode: Node;
-    focusOffset: number;
-}): void;
-/**
- * Move the selection
- */
-export declare function moveSelection(node: Element, direction: -1 | 1): void;
+export declare function hasOwnSelection(node: Node): node is EditableInputOrTextarea;
+export declare function hasNoSelection(node: Node): node is ClickableInputOrButton;

dist/types/utils/index.d.ts

@@ -6,24 +6,18 @@ export * from './click/isClickableInput';
 export * from './dataTransfer/Clipboard';
-export * from './edit/getValue';
-export * from './edit/input';
+export * from './edit/timeValue';
 export * from './edit/isContentEditable';
 export * from './edit/isEditable';
+export * from './edit/maxLength';
 export * from './edit/setFiles';
-export * from './focus/blur';
-export * from './focus/copySelection';
 export * from './focus/cursor';
-export * from './focus/focus';
 export * from './focus/getActiveElement';
 export * from './focus/getTabDestination';
 export * from './focus/isFocusable';
-export * from './focus/selectAll';
 export * from './focus/selection';
 export * from './focus/selector';
-export * from './keyboard/getKeyEventProps';
-export * from './keyboard/getUIEventModifiers';
 export * from './keyDef/readNextDescriptor';
 export * from './misc/cloneEvent';
-export * from './misc/eventWrapper';
 export * from './misc/findClosest';
 export * from './misc/getDocumentFromNode';
+export * from './misc/getTreeDiff';
 export * from './misc/getWindow';
@@ -37,2 +31,1 @@ export * from './misc/isDescendantOrSelf';
 export * from './pointer/cssPointerEvents';
-export * from './pointer/mouseButtons';

dist/types/utils/keyDef/readNextDescriptor.d.ts

@@ -1,2 +0,2 @@
-declare type Context = 'pointer' | 'keyboard';
+type Context = 'pointer' | 'keyboard';
 /**
@@ -3,0 +3,0 @@ * Read the next key definition from user input

dist/types/utils/misc/isElementType.d.ts

@@ -1,2 +0,2 @@
-declare type tag = keyof HTMLElementTagNameMap;
+type tag = keyof HTMLElementTagNameMap;
 export declare function isElementType<T extends tag, P extends {
@@ -3,0 +3,0 @@ [k: string]: unknown;

dist/types/utils/misc/level.d.ts

@@ -1,2 +0,2 @@
-import { Config } from '../../setup';
+import { type Instance } from '../../setup';
 export declare enum ApiLevel {
@@ -6,13 +6,4 @@ Trigger = 2,
 }
-declare const Level: unique symbol;
-interface LevelRefs {
-    [k: number]: object | undefined;
-}
-declare module '../../setup' {
-    interface Config {
-        [Level]?: LevelRefs;
-    }
-}
-export declare function setLevelRef(config: Config, level: ApiLevel): void;
-export declare function getLevelRef(config: Config, level: ApiLevel): object | undefined;
-export {};
+export type LevelRefs = Record<ApiLevel, object | undefined>;
+export declare function setLevelRef(instance: Instance, level: ApiLevel): void;
+export declare function getLevelRef(instance: Instance, level: ApiLevel): object | undefined;

dist/types/utils/misc/wait.d.ts

@@ -1,2 +0,2 @@
-import { Config } from '../../setup';
-export declare function wait(config: Config): Promise<[void, void]> | undefined;
+import { type Instance } from '../../setup';
+export declare function wait(config: Instance['config']): Promise<[void, void]> | undefined;

dist/types/utils/pointer/cssPointerEvents.d.ts

@@ -1,4 +0,8 @@
-import { Config } from '../../setup';
-import { ApiLevel } from '..';
-export declare function hasPointerEvents(element: Element): boolean;
+import { type Instance } from '../../setup';
+import { ApiLevel } from '../misc/level';
+export declare function hasPointerEvents(instance: Instance, element: Element): boolean;
+declare function closestPointerEventsDeclaration(element: Element): {
+    pointerEvents: string;
+    tree: Element[];
+} | undefined;
 declare const PointerEventsCheck: unique symbol;
@@ -10,7 +14,7 @@ declare global {
         } & {
-            result: boolean;
+            result: ReturnType<typeof closestPointerEventsDeclaration>;
         };
     }
 }
-export declare function assertPointerEvents(config: Config, element: Element): void;
+export declare function assertPointerEvents(instance: Instance, element: Element): void;
 export {};

package.json

 {
   "name": "@testing-library/user-event",
-  "version": "14.2.0",
+  "version": "14.5.1",
   "description": "Fire events the same way the user does",
@@ -28,45 +28,75 @@ "keywords": [
   ],
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
-  "exports": {
-    ".": {
-      "require": "./dist/index.cjs",
-      "default": "./dist/index.mjs"
-    }
-  },
-  "types": "./dist/types/index.d.ts",
   "scripts": {
-    "build": "node build.js",
+    "build": "scripts ts-build2 --cjs --target es2019",
     "lint": "kcd-scripts lint",
     "setup": "npm install && npm run validate -s",
+    "setup:env": "node --experimental-import-meta-resolve scripts/setup.js",
     "test": "kcd-scripts test",
+    "test:jest": "kcd-scripts test",
+    "test:toolbox": "NODE_OPTIONS='--experimental-vm-modules --experimental-modules --experimental-import-meta-resolve' node scripts/test.js",
     "test:debug": "kcd-scripts --inspect-brk test --runInBand",
     "test:update": "npm test -- --updateSnapshot --coverage",
-    "validate": "kcd-scripts validate",
-    "typecheck": "kcd-scripts typecheck"
+    "validate": "kcd-scripts typecheck"
   },
   "devDependencies": {
-    "@testing-library/dom": "^8.11.4",
+    "@ph.fritsche/scripts-config": "^2.4.0",
+    "@ph.fritsche/toolbox": "^1.0.0-alpha.1",
+    "@testing-library/dom": "^8.19.0",
     "@testing-library/jest-dom": "^5.16.3",
-    "@testing-library/react": "^13.0.0",
+    "@testing-library/react": "^13.4.0",
     "@types/jest-in-case": "^1.0.3",
-    "@types/react": "^17.0.42",
-    "esbuild": "^0.14.27",
-    "eslint-import-resolver-typescript": "^2.7.0",
-    "eslint-plugin-local-rules": "^1.1.0",
+    "@types/react": "^18.0.25",
+    "@types/sinonjs__fake-timers": "^8.1.2",
+    "css.escape": "^1.5.1",
+    "eslint-import-resolver-typescript": "^3.5.2",
+    "eslint-plugin-local-rules": "^1.3.2",
+    "expect": "^28.1.3",
     "is-ci": "^3.0.1",
+    "istanbul-lib-coverage": "^3.2.0",
+    "istanbul-lib-report": "^3.0.0",
+    "istanbul-lib-source-maps": "^4.0.1",
+    "istanbul-reports": "^3.1.5",
     "jest-in-case": "^1.0.2",
+    "jest-mock": "^28.1.3",
     "jest-serializer-ansi": "^1.0.3",
+    "jsdom": "^20.0.3",
     "kcd-scripts": "^12.1.0",
     "react": "^18.0.0",
     "react-dom": "^18.0.0",
-    "react17": "npm:react@^17.0.2",
-    "reactDom17": "npm:react-dom@^17.0.2",
-    "reactIs17": "npm:react-is@^17.0.2",
-    "reactTesting17": "npm:@testing-library/react@^12.1.3",
-    "typescript": "^4.1.2"
+    "shared-scripts": "^1.5.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.3"
   },
   "peerDependencies": {
     "@testing-library/dom": ">=7.21.4"
+  },
+  "dependencies": {},
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "require": "./dist/cjs/index.js",
+      "default": "./dist/esm/index.js"
+    },
+    "./dist/cjs/*": "./dist/cjs/*",
+    "./dist/esm/*": "./dist/esm/*"
+  },
+  "typesVersions": {
+    "*": {
+      "dist/types/*": [
+        "./dist/types/*"
+      ],
+      "dist/cjs/*.js": [
+        "./dist/types/*.d.ts"
+      ],
+      "dist/esm/*.js": [
+        "./dist/types/*.d.ts"
+      ],
+      "*": [
+        "./dist/types/*.d.ts"
+      ]
+    }
   }
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

443951

increased by76.16%

Number of package files

318

increased by218%

Lines of code

10956

increased by52.59%

Worsened metrics

Dev dependency count

27

increased by42.11%

No dependency changes