@react-aria/test-utils 1.0.0-beta.2 → 1.0.0-beta.3

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

@@ -0,0 +1,102 @@
+import { MenuTesterOpts, UserOpts } from './types';
+interface MenuOpenOpts {
+    /**
+     * Whether the menu needs to be long pressed to open.
+     */
+    needsLongPress?: boolean;
+    /**
+     * What interaction type to use when opening the menu. Defaults to the interaction type set on the tester.
+     */
+    interactionType?: UserOpts['interactionType'];
+    /**
+     * Whether to open the menu via ArrowUp or ArrowDown if in keyboard modality.
+     */
+    direction?: 'up' | 'down';
+}
+interface MenuSelectOpts extends MenuOpenOpts {
+    /**
+     * The index, text, or node of the option to select. Option nodes can be sourced via `options()`.
+     */
+    option: number | string | HTMLElement;
+    /**
+     * The menu's selection mode. Will affect whether or not the menu is expected to be closed upon option selection.
+     * @default 'single'
+     */
+    menuSelectionMode?: 'single' | 'multiple';
+    /**
+     * Whether or not the menu closes on select. Depends on menu implementation and configuration.
+     * @default true
+     */
+    closesOnSelect?: boolean;
+    /**
+     * Whether the option should be triggered by Space or Enter in keyboard modality.
+     * @default 'Enter'
+     */
+    keyboardActivation?: 'Space' | 'Enter';
+}
+interface MenuOpenSubmenuOpts extends MenuOpenOpts {
+    /**
+     * The text or node of the submenu trigger to open. Available submenu trigger nodes can be sourced via `submenuTriggers`.
+     */
+    submenuTrigger: string | HTMLElement;
+}
+export declare class MenuTester {
+    private user;
+    private _interactionType;
+    private _advanceTimer;
+    private _trigger;
+    private _isSubmenu;
+    private _rootMenu;
+    constructor(opts: MenuTesterOpts);
+    /**
+     * Set the interaction type used by the menu tester.
+     */
+    setInteractionType(type: UserOpts['interactionType']): void;
+    /**
+     * Opens the menu. Defaults to using the interaction type set on the menu tester.
+     */
+    open(opts?: MenuOpenOpts): Promise<void>;
+    /**
+     * Returns a option matching the specified index or text content.
+     */
+    findOption(opts: {
+        optionIndexOrText: number | string;
+    }): HTMLElement;
+    /**
+     * Selects the desired menu option. Defaults to using the interaction type set on the menu tester. If necessary, will open the menu dropdown beforehand.
+     * The desired option can be targeted via the option's node, the option's text, or the option's index.
+     */
+    selectOption(opts: MenuSelectOpts): Promise<void>;
+    /**
+     * Opens the submenu. Defaults to using the interaction type set on the menu tester. The submenu trigger can be targeted via the trigger's node or the trigger's text.
+     */
+    openSubmenu(opts: MenuOpenSubmenuOpts): Promise<MenuTester | null>;
+    private keyboardNavigateToOption;
+    /**
+     * Closes the menu.
+     */
+    close(): Promise<void>;
+    /**
+     * Returns the menu's trigger.
+     */
+    get trigger(): HTMLElement;
+    /**
+     * Returns the menu if present.
+     */
+    get menu(): HTMLElement | null;
+    /**
+     * Returns the menu's sections if any.
+     */
+    get sections(): HTMLElement[];
+    /**
+     * Returns the menu's options if present. Can be filtered to a subsection of the menu if provided via `element`.
+     */
+    options(opts?: {
+        element?: HTMLElement;
+    }): HTMLElement[];
+    /**
+     * Returns the menu's submenu triggers if any.
+     */
+    get submenuTriggers(): HTMLElement[];
+}
+export {};

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

@@ -0,0 +1,46 @@
+import { RadioGroupTesterOpts, UserOpts } from './types';
+interface TriggerRadioOptions {
+    /**
+     * What interaction type to use when triggering a radio. Defaults to the interaction type set on the tester.
+     */
+    interactionType?: UserOpts['interactionType'];
+    /**
+     * The index, text, or node of the radio to toggle selection for.
+     */
+    radio: number | string | HTMLElement;
+}
+export declare class RadioGroupTester {
+    private user;
+    private _interactionType;
+    private _radiogroup;
+    private _direction;
+    constructor(opts: RadioGroupTesterOpts);
+    /**
+     * Set the interaction type used by the radio tester.
+     */
+    setInteractionType(type: UserOpts['interactionType']): void;
+    /**
+     * Returns a radio matching the specified index or text content.
+     */
+    findRadio(opts: {
+        radioIndexOrText: number | string;
+    }): HTMLElement;
+    private keyboardNavigateToRadio;
+    /**
+     * Triggers the specified radio. Defaults to using the interaction type set on the radio tester.
+     */
+    triggerRadio(opts: TriggerRadioOptions): Promise<void>;
+    /**
+     * Returns the radiogroup.
+     */
+    get radiogroup(): HTMLElement;
+    /**
+     * Returns the radios.
+     */
+    get radios(): HTMLElement[];
+    /**
+     * Returns the currently selected radio in the radiogroup if any.
+     */
+    get selectedRadio(): HTMLElement | null;
+}
+export {};

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

@@ -0,0 +1,67 @@
+import { SelectTesterOpts, UserOpts } from './types';
+interface SelectOpenOpts {
+    /**
+     * What interaction type to use when opening the select. Defaults to the interaction type set on the tester.
+     */
+    interactionType?: UserOpts['interactionType'];
+}
+interface SelectTriggerOptionOpts extends SelectOpenOpts {
+    /**
+     * The index, text, or node of the option to select. Option nodes can be sourced via `options()`.
+     */
+    option: number | string | HTMLElement;
+    /**
+     * Whether or not the select closes on selection. Depends on select implementation and configuration.
+     * @default true
+     */
+    closesOnSelect?: boolean;
+}
+export declare class SelectTester {
+    private user;
+    private _interactionType;
+    private _trigger;
+    constructor(opts: SelectTesterOpts);
+    /**
+     * Set the interaction type used by the select tester.
+     */
+    setInteractionType(type: UserOpts['interactionType']): void;
+    /**
+     * Opens the select. Defaults to using the interaction type set on the select tester.
+     */
+    open(opts?: SelectOpenOpts): Promise<void>;
+    /**
+     * Closes the select.
+     */
+    close(): Promise<void>;
+    /**
+     * Returns a option matching the specified index or text content.
+     */
+    findOption(opts: {
+        optionIndexOrText: number | string;
+    }): HTMLElement;
+    private keyboardNavigateToOption;
+    /**
+     * Selects the desired select option. Defaults to using the interaction type set on the select tester. If necessary, will open the select dropdown beforehand.
+     * The desired option can be targeted via the option's node, the option's text, or the option's index.
+     */
+    selectOption(opts: SelectTriggerOptionOpts): Promise<void>;
+    /**
+     * Returns the select's options if present. Can be filtered to a subsection of the listbox if provided via `element`.
+     */
+    options(opts?: {
+        element?: HTMLElement;
+    }): HTMLElement[];
+    /**
+     * Returns the select's trigger.
+     */
+    get trigger(): HTMLElement;
+    /**
+     * Returns the select's listbox if present.
+     */
+    get listbox(): HTMLElement | null;
+    /**
+     * Returns the select's sections if present.
+     */
+    get sections(): HTMLElement[];
+}
+export {};

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

@@ -0,0 +1,104 @@
+import { BaseGridRowInteractionOpts, GridRowActionOpts, TableTesterOpts, ToggleGridRowOpts, UserOpts } from './types';
+interface TableToggleRowOpts extends ToggleGridRowOpts {
+}
+interface TableToggleExpansionOpts extends BaseGridRowInteractionOpts {
+}
+interface TableToggleSortOpts {
+    /**
+     * The index, text, or node of the column to toggle selection for.
+     */
+    column: number | string | HTMLElement;
+    /**
+     * What interaction type to use when sorting the column. Defaults to the interaction type set on the tester.
+     */
+    interactionType?: UserOpts['interactionType'];
+}
+interface TableColumnHeaderActionOpts extends TableToggleSortOpts {
+    /**
+     * The index of the column header action to trigger.
+     */
+    action: number;
+}
+interface TableRowActionOpts extends GridRowActionOpts {
+}
+export declare class TableTester {
+    private user;
+    private _interactionType;
+    private _advanceTimer;
+    private _table;
+    constructor(opts: TableTesterOpts);
+    /**
+     * Set the interaction type used by the table tester.
+     */
+    setInteractionType(type: UserOpts['interactionType']): void;
+    private keyboardNavigateToRow;
+    /**
+     * Toggles the selection for the specified table row. Defaults to using the interaction type set on the table tester.
+     */
+    toggleRowSelection(opts: TableToggleRowOpts): Promise<void>;
+    /**
+     * Toggles the expansion for the specified tree row. Defaults to using the interaction type set on the tree tester.
+     */
+    toggleRowExpansion(opts: TableToggleExpansionOpts): Promise<void>;
+    /**
+     * Toggles the sort order for the specified table column. Defaults to using the interaction type set on the table tester.
+     */
+    toggleSort(opts: TableToggleSortOpts): Promise<void>;
+    /**
+     * Triggers an action for the specified table column menu. Defaults to using the interaction type set on the table tester.
+     */
+    triggerColumnHeaderAction(opts: TableColumnHeaderActionOpts): Promise<void>;
+    /**
+     * Triggers the action for the specified table row. Defaults to using the interaction type set on the table tester.
+     */
+    triggerRowAction(opts: TableRowActionOpts): Promise<void>;
+    /**
+     * Toggle selection for all rows in the table. Defaults to using the interaction type set on the table tester.
+     */
+    toggleSelectAll(opts?: {
+        interactionType?: UserOpts['interactionType'];
+    }): Promise<void>;
+    /**
+     * Returns a row matching the specified index or text content.
+     */
+    findRow(opts: {
+        rowIndexOrText: number | string;
+    }): HTMLElement;
+    /**
+     * Returns a cell matching the specified text content.
+     */
+    findCell(opts: {
+        text: string;
+    }): HTMLElement;
+    /**
+     * Returns the table.
+     */
+    get table(): HTMLElement;
+    /**
+     * Returns the row groups within the table.
+     */
+    get rowGroups(): HTMLElement[];
+    /**
+     * Returns the columns within the table.
+     */
+    get columns(): HTMLElement[];
+    /**
+     * Returns the rows within the table if any.
+     */
+    get rows(): HTMLElement[];
+    /**
+     * Returns the currently selected rows within the table if any.
+     */
+    get selectedRows(): HTMLElement[];
+    /**
+     * Returns the row headers within the table if any.
+     */
+    get rowHeaders(): HTMLElement[];
+    /**
+     * Returns the cells within the table if any. Can be filtered against a specific row if provided via `element`.
+     */
+    cells(opts?: {
+        element?: HTMLElement;
+    }): HTMLElement[];
+}
+export {};

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

@@ -0,0 +1,58 @@
+import { TabsTesterOpts, UserOpts } from './types';
+interface TriggerTabOptions {
+    /**
+     * What interaction type to use when triggering a tab. Defaults to the interaction type set on the tester.
+     */
+    interactionType?: UserOpts['interactionType'];
+    /**
+     * The index, text, or node of the tab to toggle selection for.
+     */
+    tab: number | string | HTMLElement;
+    /**
+     * Whether the tab needs to be activated manually rather than on focus.
+     */
+    manualActivation?: boolean;
+}
+export declare class TabsTester {
+    private user;
+    private _interactionType;
+    private _tablist;
+    private _direction;
+    constructor(opts: TabsTesterOpts);
+    /**
+     * Set the interaction type used by the tabs tester.
+     */
+    setInteractionType(type: UserOpts['interactionType']): void;
+    /**
+     * Returns a tab matching the specified index or text content.
+     */
+    findTab(opts: {
+        tabIndexOrText: number | string;
+    }): HTMLElement;
+    private keyboardNavigateToTab;
+    /**
+     * Triggers the specified tab. Defaults to using the interaction type set on the tabs tester.
+     */
+    triggerTab(opts: TriggerTabOptions): Promise<void>;
+    /**
+     * Returns the tablist.
+     */
+    get tablist(): HTMLElement;
+    /**
+     * Returns the tabpanels.
+     */
+    get tabpanels(): HTMLElement[];
+    /**
+     * Returns the tabs in the tablist.
+     */
+    get tabs(): HTMLElement[];
+    /**
+     * Returns the currently selected tab in the tablist if any.
+     */
+    get selectedTab(): HTMLElement | null;
+    /**
+     * Returns the currently active tabpanel if any.
+     */
+    get activeTabpanel(): HTMLElement | null;
+}
+export {};

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

@@ -0,0 +1,6 @@
+/**
+ * Enables reading pageX/pageY from fireEvent.mouse*(..., {pageX: ..., pageY: ...}).
+ */
+export declare function installMouseEvent(): void;
+export declare function definePointerEvent(): void;
+export declare function installPointerEvent(): void;

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

@@ -0,0 +1,57 @@
+import { BaseGridRowInteractionOpts, GridRowActionOpts, ToggleGridRowOpts, TreeTesterOpts, UserOpts } from './types';
+interface TreeToggleExpansionOpts extends BaseGridRowInteractionOpts {
+}
+interface TreeToggleRowOpts extends ToggleGridRowOpts {
+}
+interface TreeRowActionOpts extends GridRowActionOpts {
+}
+export declare class TreeTester {
+    private user;
+    private _interactionType;
+    private _advanceTimer;
+    private _tree;
+    constructor(opts: TreeTesterOpts);
+    /**
+     * Set the interaction type used by the tree tester.
+     */
+    setInteractionType(type: UserOpts['interactionType']): void;
+    /**
+     * Returns a row matching the specified index or text content.
+     */
+    findRow(opts: {
+        rowIndexOrText: number | string;
+    }): HTMLElement;
+    private keyboardNavigateToRow;
+    /**
+     * Toggles the selection for the specified tree row. Defaults to using the interaction type set on the tree tester.
+     * Note that this will endevor to always add/remove JUST the provided row to the set of selected rows.
+     */
+    toggleRowSelection(opts: TreeToggleRowOpts): Promise<void>;
+    /**
+     * Toggles the expansion for the specified tree row. Defaults to using the interaction type set on the tree tester.
+     */
+    toggleRowExpansion(opts: TreeToggleExpansionOpts): Promise<void>;
+    /**
+     * Triggers the action for the specified tree row. Defaults to using the interaction type set on the tree tester.
+     */
+    triggerRowAction(opts: TreeRowActionOpts): Promise<void>;
+    /**
+     * Returns the tree.
+     */
+    get tree(): HTMLElement;
+    /**
+     * Returns the tree's rows if any.
+     */
+    get rows(): HTMLElement[];
+    /**
+     * Returns the tree's selected rows if any.
+     */
+    get selectedRows(): HTMLElement[];
+    /**
+     * Returns the tree's cells if any. Can be filtered against a specific row if provided via `element`.
+     */
+    cells(opts?: {
+        element?: HTMLElement;
+    }): HTMLElement[];
+}
+export {};

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

@@ -0,0 +1,136 @@
+export type Orientation = 'horizontal' | 'vertical';
+export type Direction = 'ltr' | 'rtl';
+export interface UserOpts {
+    /**
+     * The interaction type (mouse, touch, keyboard) that the test util user will use when interacting with a component. This can be overridden
+     * at the aria pattern tester level if needed.
+     * @default mouse
+     */
+    interactionType?: 'mouse' | 'touch' | 'keyboard';
+    /**
+     * A function used by the test utils to advance timers during interactions. Required for certain aria patterns (e.g. table). This can be overridden
+     * at the aria pattern tester level if needed.
+     */
+    advanceTimer?: (time: number) => unknown | Promise<unknown>;
+}
+export interface BaseTesterOpts extends UserOpts {
+    /** @private */
+    user?: any;
+    /** The base element for the given tester (e.g. the table, menu trigger button, etc). */
+    root: HTMLElement;
+}
+export interface CheckboxGroupTesterOpts extends BaseTesterOpts {
+}
+export interface ComboBoxTesterOpts extends BaseTesterOpts {
+    /**
+     * The base element for the combobox. If provided the wrapping element around the target combobox (as is the the case with a ref provided to RSP ComboBox),
+     * will automatically search for the combobox element within.
+     */
+    root: HTMLElement;
+    /**
+     * The node of the combobox trigger button if any. If not provided, we will try to automatically use any button
+     * within the `root` provided or that the `root` serves as the trigger.
+     */
+    trigger?: HTMLElement;
+}
+export interface DialogTesterOpts extends BaseTesterOpts {
+    /**
+     * The trigger element for the dialog.
+     */
+    root: HTMLElement;
+    /**
+     * The overlay type of the dialog. Used to inform the tester how to find the dialog.
+     */
+    overlayType?: 'modal' | 'popover';
+}
+export interface GridListTesterOpts extends BaseTesterOpts {
+}
+export interface ListBoxTesterOpts extends BaseTesterOpts {
+    /**
+     * A function used by the test utils to advance timers during interactions.
+     */
+    advanceTimer?: UserOpts['advanceTimer'];
+}
+export interface MenuTesterOpts extends BaseTesterOpts {
+    /**
+     * The trigger element for the menu.
+     */
+    root: HTMLElement;
+    /**
+     * Whether the current menu is a submenu.
+     */
+    isSubmenu?: boolean;
+    /**
+     * The root menu of the menu tree. Only available if the menu is a submenu.
+     */
+    rootMenu?: HTMLElement;
+}
+export interface RadioGroupTesterOpts extends BaseTesterOpts {
+    /**
+     * The horizontal layout direction, typically affected by locale.
+     * @default 'ltr'
+     */
+    direction?: Direction;
+}
+export interface SelectTesterOpts extends BaseTesterOpts {
+    /**
+     * The trigger element for the select. If provided the wrapping element around the target select (as is the case with a ref provided to RSP Select),
+     * will automatically search for the select's trigger element within.
+     */
+    root: HTMLElement;
+}
+export interface TableTesterOpts extends BaseTesterOpts {
+    /**
+     * A function used by the test utils to advance timers during interactions.
+     */
+    advanceTimer?: UserOpts['advanceTimer'];
+}
+export interface TabsTesterOpts extends BaseTesterOpts {
+    /**
+     * The horizontal layout direction, typically affected by locale.
+     * @default 'ltr'
+     */
+    direction?: Direction;
+}
+export interface TreeTesterOpts extends BaseTesterOpts {
+    /**
+     * A function used by the test utils to advance timers during interactions.
+     */
+    advanceTimer?: UserOpts['advanceTimer'];
+}
+export interface BaseGridRowInteractionOpts {
+    /**
+     * The index, text, or node of the row to target.
+     */
+    row: number | string | HTMLElement;
+    /**
+     * What interaction type to use when interacting with the row. Defaults to the interaction type set on the tester.
+     */
+    interactionType?: UserOpts['interactionType'];
+}
+export interface ToggleGridRowOpts extends BaseGridRowInteractionOpts {
+    /**
+     * Whether the row needs to be long pressed to be selected. Depends on the components implementation.
+     */
+    needsLongPress?: boolean;
+    /**
+     * Whether the checkbox should be used to select the row. If false, will attempt to select the row via press.
+     * @default 'true'
+     */
+    checkboxSelection?: boolean;
+    /**
+     * Whether the grid has a selectionBehavior of "toggle" or "replace" (aka highlight selection). This affects the user operations
+     * required to toggle row selection by adding modifier keys during user actions, useful when performing multi-row selection in a "selectionBehavior: 'replace'" grid.
+     * If you would like to still simulate user actions (aka press) without these modifiers keys for a "selectionBehavior: replace" grid, simply omit this option.
+     * See the "Selection Behavior" section of the appropriate React Aria Component docs for more information (e.g. https://react-spectrum.adobe.com/react-aria/Tree.html#selection-behavior).
+     *
+     * @default 'toggle'
+     */
+    selectionBehavior?: 'toggle' | 'replace';
+}
+export interface GridRowActionOpts extends BaseGridRowInteractionOpts {
+    /**
+     * Whether or not the row needs a double click to trigger the row action. Depends on the components implementation.
+     */
+    needsDoubleClick?: boolean;
+}

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

@@ -0,0 +1,47 @@
+import { CheckboxGroupTester } from './checkboxgroup';
+import { CheckboxGroupTesterOpts, ComboBoxTesterOpts, DialogTesterOpts, GridListTesterOpts, ListBoxTesterOpts, MenuTesterOpts, RadioGroupTesterOpts, SelectTesterOpts, TableTesterOpts, TabsTesterOpts, TreeTesterOpts, UserOpts } from './types';
+import { ComboBoxTester } from './combobox';
+import { DialogTester } from './dialog';
+import { GridListTester } from './gridlist';
+import { ListBoxTester } from './listbox';
+import { MenuTester } from './menu';
+import { RadioGroupTester } from './radiogroup';
+import { SelectTester } from './select';
+import { TableTester } from './table';
+import { TabsTester } from './tabs';
+import { TreeTester } from './tree';
+declare let keyToUtil: {
+    'CheckboxGroup': typeof CheckboxGroupTester;
+    'ComboBox': typeof ComboBoxTester;
+    'Dialog': typeof DialogTester;
+    'GridList': typeof GridListTester;
+    'ListBox': typeof ListBoxTester;
+    'Menu': typeof MenuTester;
+    'RadioGroup': typeof RadioGroupTester;
+    'Select': typeof SelectTester;
+    'Table': typeof TableTester;
+    'Tabs': typeof TabsTester;
+    'Tree': typeof TreeTester;
+};
+export type PatternNames = keyof typeof keyToUtil;
+type Tester<T> = T extends 'CheckboxGroup' ? CheckboxGroupTester : T extends 'ComboBox' ? ComboBoxTester : T extends 'Dialog' ? DialogTester : T extends 'GridList' ? GridListTester : T extends 'ListBox' ? ListBoxTester : T extends 'Menu' ? MenuTester : T extends 'RadioGroup' ? RadioGroupTester : T extends 'Select' ? SelectTester : T extends 'Table' ? TableTester : T extends 'Tabs' ? TabsTester : T extends 'Tree' ? TreeTester : never;
+type TesterOpts<T> = T extends 'CheckboxGroup' ? CheckboxGroupTesterOpts : T extends 'ComboBox' ? ComboBoxTesterOpts : T extends 'Dialog' ? DialogTesterOpts : T extends 'GridList' ? GridListTesterOpts : T extends 'ListBox' ? ListBoxTesterOpts : T extends 'Menu' ? MenuTesterOpts : T extends 'RadioGroup' ? RadioGroupTesterOpts : T extends 'Select' ? SelectTesterOpts : T extends 'Table' ? TableTesterOpts : T extends 'Tabs' ? TabsTesterOpts : T extends 'Tree' ? TreeTesterOpts : never;
+export declare class User {
+    private user;
+    /**
+     * The interaction type (mouse, touch, keyboard) that the test util user will use when interacting with a component. This can be overridden
+     * at the aria pattern util level if needed.
+     * @default mouse
+     */
+    interactionType: UserOpts['interactionType'];
+    /**
+     * A function used by the test utils to advance timers during interactions. Required for certain aria patterns (e.g. table).
+     */
+    advanceTimer: UserOpts['advanceTimer'];
+    constructor(opts?: UserOpts);
+    /**
+     * Creates an aria pattern tester, inheriting the options provided to the original user.
+     */
+    createTester<T extends PatternNames>(patternName: T, opts: TesterOpts<T>): Tester<T>;
+}
+export {};

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

@@ -0,0 +1,2 @@
+import { pointerKey } from '@testing-library/user-event';
+export declare let pointerMap: pointerKey[];

package/package.json

@@ -1,20 +1,17 @@
 {
   "name": "@react-aria/test-utils",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.3",
   "description": "Testing utils for react-aria patterns",
   "license": "Apache-2.0",
   "main": "dist/main.js",
   "module": "dist/module.js",
   "exports": {
     "source": "./src/index.ts",
-    "types": [
-      "./dist/types.d.ts",
-      "./src/index.ts"
-    ],
+    "types": "./dist/types/src/index.d.ts",
     "import": "./dist/import.mjs",
     "require": "./dist/main.js"
   },
-  "types": "dist/types.d.ts",
+  "types": "./dist/types/src/index.d.ts",
   "source": "src/index.ts",
   "files": [
     "dist",
@@ -37,5 +34,8 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "4d838da5bfe36abb35aed166995a9ef63825370f"
+  "targets": {
+    "types": false
+  },
+  "gitHead": "a6999bdf494a2e9c0381a5881908328bdd22ddae"
 }