@primer/components 32.1.0 → 33.0.0-rc.b495ba4a

package/lib-esm/__tests__/Tooltip.test.js

@@ -0,0 +1,59 @@
+import React from 'react';
+import Tooltip from '../Tooltip';
+import { render, renderClasses, rendersClass, behavesAsComponent, checkExports } from '../utils/testing';
+import { render as HTMLRender, cleanup } from '@testing-library/react';
+import { axe, toHaveNoViolations } from 'jest-axe';
+import 'babel-polyfill';
+expect.extend(toHaveNoViolations);
+describe('Tooltip', () => {
+  behavesAsComponent({
+    Component: Tooltip
+  });
+  checkExports('Tooltip', {
+    default: Tooltip
+  });
+  it('should have no axe violations', async () => {
+    const {
+      container
+    } = HTMLRender( /*#__PURE__*/React.createElement(Tooltip, {
+      text: "hi"
+    }));
+    const results = await axe(container);
+    expect(results).toHaveNoViolations();
+    cleanup();
+  });
+  it('renders a <span> with the "tooltipped" class', () => {
+    expect(render( /*#__PURE__*/React.createElement(Tooltip, null)).type).toEqual('span');
+    expect(renderClasses( /*#__PURE__*/React.createElement(Tooltip, null))).toContain('tooltipped-n');
+  });
+  it('respects the "align" prop', () => {
+    expect(rendersClass( /*#__PURE__*/React.createElement(Tooltip, {
+      align: "left"
+    }), 'tooltipped-align-left-2')).toBe(true);
+    expect(rendersClass( /*#__PURE__*/React.createElement(Tooltip, {
+      align: "right"
+    }), 'tooltipped-align-right-2')).toBe(true);
+  });
+  it('respects the "direction" prop', () => {
+    for (const direction of Tooltip.directions) {
+      expect(rendersClass( /*#__PURE__*/React.createElement(Tooltip, {
+        direction: direction
+      }), `tooltipped-${direction}`)).toBe(true);
+    }
+  });
+  it('respects the "noDelay" prop', () => {
+    expect(rendersClass( /*#__PURE__*/React.createElement(Tooltip, {
+      noDelay: true
+    }), 'tooltipped-no-delay')).toBe(true);
+  });
+  it('respects the "text" prop', () => {
+    expect(render( /*#__PURE__*/React.createElement(Tooltip, {
+      text: "hi"
+    })).props['aria-label']).toEqual('hi');
+  });
+  it('respects the "wrap" prop', () => {
+    expect(rendersClass( /*#__PURE__*/React.createElement(Tooltip, {
+      wrap: true
+    }), 'tooltipped-multiline')).toBe(true);
+  });
+});

package/lib-esm/__tests__/Tooltip.types.test.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+export declare function shouldAcceptCallWithNoProps(): JSX.Element;
+export declare function shouldNotAcceptSystemProps(): JSX.Element;

package/lib-esm/__tests__/Tooltip.types.test.js

@@ -0,0 +1,13 @@
+import React from 'react';
+import Tooltip from '../Tooltip';
+export function shouldAcceptCallWithNoProps() {
+  return /*#__PURE__*/React.createElement(Tooltip, null);
+}
+shouldAcceptCallWithNoProps.displayName = "shouldAcceptCallWithNoProps";
+export function shouldNotAcceptSystemProps() {
+  // @ts-expect-error system props should not be accepted
+  return /*#__PURE__*/React.createElement(Tooltip, {
+    backgroundColor: "thistle"
+  });
+}
+shouldNotAcceptSystemProps.displayName = "shouldNotAcceptSystemProps";

package/lib-esm/__tests__/Truncate.test.d.ts

@@ -0,0 +1 @@
+import 'babel-polyfill';

package/lib-esm/__tests__/Truncate.test.js

@@ -0,0 +1,53 @@
+import React from 'react';
+import { Truncate } from '..';
+import { render, behavesAsComponent, checkExports } from '../utils/testing';
+import { render as HTMLRender, cleanup } from '@testing-library/react';
+import { axe, toHaveNoViolations } from 'jest-axe';
+import 'babel-polyfill';
+expect.extend(toHaveNoViolations);
+describe('Truncate', () => {
+  behavesAsComponent({
+    Component: Truncate,
+    toRender: () => /*#__PURE__*/React.createElement(Truncate, {
+      title: "a-long-branch-name"
+    })
+  });
+  checkExports('Truncate', {
+    default: Truncate
+  });
+  it('renders a <div> by default', () => {
+    expect(render( /*#__PURE__*/React.createElement(Truncate, {
+      title: "a-long-branch-name"
+    })).type).toEqual('div');
+  });
+  it('should have no axe violations', async () => {
+    const {
+      container
+    } = HTMLRender( /*#__PURE__*/React.createElement(Truncate, {
+      title: "a-long-branch-name"
+    }, "a-long-branch-name"));
+    const results = await axe(container);
+    expect(results).toHaveNoViolations();
+    cleanup();
+  });
+  it('respects the maxWidth prop', () => {
+    expect(render( /*#__PURE__*/React.createElement(Truncate, {
+      maxWidth: 250,
+      title: "a-long-branch-name"
+    }))).toHaveStyleRule('max-width', '250px');
+  });
+  it('respects the inline prop', () => {
+    expect(render( /*#__PURE__*/React.createElement(Truncate, {
+      inline: true,
+      title: "a-long-branch-name"
+    }))).toHaveStyleRule('display', 'inline-block');
+  });
+  it('respects the expandable prop', () => {
+    expect(render( /*#__PURE__*/React.createElement(Truncate, {
+      expandable: true,
+      title: "a-long-branch-name"
+    }))).toHaveStyleRule('max-width', '10000px', {
+      modifier: ':hover'
+    });
+  });
+});

package/lib-esm/__tests__/Truncate.types.test.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+export declare function shouldAcceptCallWithNoProps(): JSX.Element;
+export declare function shouldNotAcceptSystemProps(): JSX.Element;

package/lib-esm/__tests__/Truncate.types.test.js

@@ -0,0 +1,16 @@
+import React from 'react';
+import Truncate from '../Truncate';
+export function shouldAcceptCallWithNoProps() {
+  return /*#__PURE__*/React.createElement(Truncate, {
+    title: "Hello"
+  });
+}
+shouldAcceptCallWithNoProps.displayName = "shouldAcceptCallWithNoProps";
+export function shouldNotAcceptSystemProps() {
+  // @ts-expect-error system props should not be accepted
+  return /*#__PURE__*/React.createElement(Truncate, {
+    title: "Hello",
+    backgroundColor: "indigo"
+  });
+}
+shouldNotAcceptSystemProps.displayName = "shouldNotAcceptSystemProps";

package/lib-esm/__tests__/UnderlineNav.test.d.ts

@@ -0,0 +1 @@
+import 'babel-polyfill';

package/lib-esm/__tests__/UnderlineNav.test.js

@@ -0,0 +1,60 @@
+import React from 'react';
+import { UnderlineNav } from '..';
+import { mount, render, rendersClass, behavesAsComponent, checkExports } from '../utils/testing';
+import { render as HTMLRender, cleanup } from '@testing-library/react';
+import { axe, toHaveNoViolations } from 'jest-axe';
+import 'babel-polyfill';
+expect.extend(toHaveNoViolations);
+describe('UnderlineNav', () => {
+  behavesAsComponent({
+    Component: UnderlineNav
+  });
+  checkExports('UnderlineNav', {
+    default: UnderlineNav
+  });
+  it('should have no axe violations', async () => {
+    const {
+      container
+    } = HTMLRender( /*#__PURE__*/React.createElement(UnderlineNav, null));
+    const results = await axe(container);
+    expect(results).toHaveNoViolations();
+    cleanup();
+  });
+  it('renders a <nav>', () => {
+    expect(render( /*#__PURE__*/React.createElement(UnderlineNav, null)).type).toEqual('nav');
+  });
+  it('adds the UnderlineNav class', () => {
+    expect(rendersClass( /*#__PURE__*/React.createElement(UnderlineNav, null), 'UnderlineNav')).toEqual(true);
+  });
+  it('respects the "align" prop', () => {
+    expect(rendersClass( /*#__PURE__*/React.createElement(UnderlineNav, {
+      align: "right"
+    }), 'UnderlineNav--right')).toEqual(true);
+  });
+  it('respects the "full" prop', () => {
+    expect(rendersClass( /*#__PURE__*/React.createElement(UnderlineNav, {
+      full: true
+    }), 'UnderlineNav--full')).toEqual(true);
+  });
+  it('sets aria-label to the "label" prop', () => {
+    expect(render( /*#__PURE__*/React.createElement(UnderlineNav, {
+      label: "foo"
+    })).props['aria-label']).toEqual('foo');
+  });
+  it('wraps its children in an "UnderlineNav-body" div', () => {
+    const children = /*#__PURE__*/React.createElement("b", null, "yo");
+    const wrapper = mount( /*#__PURE__*/React.createElement(UnderlineNav, null, children));
+    const body = wrapper.find('.UnderlineNav-body');
+    expect(body.exists()).toEqual(true);
+    expect(body.childAt(0).type()).toEqual('b');
+  });
+  it('respects the "actions" prop', () => {
+    const content = /*#__PURE__*/React.createElement("h1", null, "hi!");
+    const wrapper = mount( /*#__PURE__*/React.createElement(UnderlineNav, {
+      actions: content
+    }));
+    const actions = wrapper.find('.UnderlineNav-actions');
+    expect(actions.exists()).toEqual(true);
+    expect(actions.text()).toEqual('hi!');
+  });
+});

package/lib-esm/__tests__/UnderlineNav.types.test.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+export declare function shouldAcceptCallWithNoProps(): JSX.Element;
+export declare function shouldNotAcceptSystemProps(): JSX.Element;

package/lib-esm/__tests__/UnderlineNav.types.test.js

@@ -0,0 +1,12 @@
+import React from 'react';
+import UnderlineNav from '../UnderlineNav';
+export function shouldAcceptCallWithNoProps() {
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(UnderlineNav, null), /*#__PURE__*/React.createElement(UnderlineNav.Link, null));
+}
+export function shouldNotAcceptSystemProps() {
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(UnderlineNav, {
+    backgroundColor: "snow"
+  }), /*#__PURE__*/React.createElement(UnderlineNav.Link, {
+    backgroundColor: "springgreen"
+  }));
+}

package/lib-esm/__tests__/UnderlineNavLink.test.d.ts

@@ -0,0 +1 @@
+import 'babel-polyfill';

package/lib-esm/__tests__/UnderlineNavLink.test.js

@@ -0,0 +1,41 @@
+import React from 'react';
+import { UnderlineNav } from '..';
+import { render, behavesAsComponent } from '../utils/testing';
+import { render as HTMLRender, cleanup } from '@testing-library/react';
+import { axe, toHaveNoViolations } from 'jest-axe';
+import 'babel-polyfill';
+expect.extend(toHaveNoViolations);
+describe('UnderlineNav.Link', () => {
+  behavesAsComponent({
+    Component: UnderlineNav.Link
+  });
+  it('renders an <a> by default', () => {
+    expect(render( /*#__PURE__*/React.createElement(UnderlineNav.Link, null)).type).toEqual('a');
+  });
+  it('should have no axe violations', async () => {
+    const {
+      container
+    } = HTMLRender( /*#__PURE__*/React.createElement(UnderlineNav.Link, {
+      href: "www.github.com"
+    }, "Go to GitHub"));
+    const results = await axe(container);
+    expect(results).toHaveNoViolations();
+    cleanup();
+  });
+  it('respects the "selected" prop', () => {
+    expect(render( /*#__PURE__*/React.createElement(UnderlineNav.Link, {
+      selected: true
+    }))).toMatchSnapshot();
+  });
+  it('adds activeClassName={SELECTED_CLASS} when it gets a "to" prop', () => {
+    const Link = ({
+      theme: _ignoredTheme,
+      ...props
+    }) => /*#__PURE__*/React.createElement("div", props);
+
+    expect(render( /*#__PURE__*/React.createElement(UnderlineNav.Link, {
+      as: Link,
+      to: "#"
+    }))).toMatchSnapshot();
+  });
+});

package/lib-esm/__tests__/behaviors/anchoredPosition.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib-esm/__tests__/behaviors/anchoredPosition.test.js

@@ -0,0 +1,388 @@
+import { getAnchoredPosition } from '../../behaviors/anchoredPosition';
+/*
+
+Note: In each test below, we check the calculation from getAnchoredPosition against exact
+values. For each `expect` call, there is an accompanying comment that distills the effective
+calculation from the inputs, which may help debugging in the event of a test failure.
+
+*/
+// The DOMRect constructor isn't available in JSDOM, so we improvise here.
+
+function makeDOMRect(x, y, width, height) {
+  return {
+    x,
+    y,
+    width,
+    height,
+    top: y,
+    left: x,
+    right: x + width,
+    bottom: y + height,
+
+    toJSON() {
+      return this;
+    }
+
+  };
+} // Since Jest/JSDOM doesn't support layout, we can stub out getBoundingClientRect if we know the
+// correct dimensions. JSDOM will handle the rest of the DOM API used by getAnchoredPosition.
+
+
+function createVirtualDOM(parentRect, anchorRect, floatingRect, parentBorders = {
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0
+}) {
+  const parent = document.createElement('div');
+  parent.style.overflow = 'hidden';
+  parent.style.position = 'relative';
+  parent.style.borderTopWidth = `${parentBorders.top}px`;
+  parent.style.borderRightWidth = `${parentBorders.right}px`;
+  parent.style.borderBottomWidth = `${parentBorders.bottom}px`;
+  parent.style.borderLeftWidth = `${parentBorders.left}px`;
+  parent.id = 'parent'; // eslint-disable-next-line github/unescaped-html-literal
+
+  parent.innerHTML = '<div id="float"></div><div id="anchor"></div>';
+  const float = parent.querySelector('#float');
+  const anchor = parent.querySelector('#anchor');
+
+  anchor.getBoundingClientRect = () => anchorRect;
+
+  parent.getBoundingClientRect = () => parentRect;
+
+  float.getBoundingClientRect = () => floatingRect;
+
+  return {
+    float,
+    parent,
+    anchor
+  };
+}
+
+describe('getAnchoredPosition', () => {
+  it('returns the correct position in the default case with no overflow', () => {
+    const anchorRect = makeDOMRect(300, 200, 50, 50);
+    const floatingRect = makeDOMRect(NaN, NaN, 100, 100); // eslint-disable-next-line github/unescaped-html-literal
+
+    document.body.innerHTML = '<div id="float"></div><div id="anchor"></div>';
+    const float = document.querySelector('#float');
+    const anchor = document.querySelector('#anchor');
+
+    float.getBoundingClientRect = () => floatingRect;
+
+    anchor.getBoundingClientRect = () => anchorRect;
+
+    document.body.getBoundingClientRect = () => makeDOMRect(0, 0, 1920, 0);
+
+    Object.defineProperty(window, 'innerHeight', {
+      get: () => 1080
+    });
+    const settings = {
+      anchorOffset: 4
+    };
+    const {
+      top,
+      left
+    } = getAnchoredPosition(float, anchor, settings);
+    expect(top).toEqual(254);
+    expect(left).toEqual(300);
+  });
+  it('returns the correct position in the default case with no overflow, inside a clipping parent', () => {
+    const parentRect = makeDOMRect(20, 20, 500, 500);
+    const anchorRect = makeDOMRect(300, 200, 50, 50);
+    const floatingRect = makeDOMRect(NaN, NaN, 100, 100);
+    const {
+      float,
+      anchor
+    } = createVirtualDOM(parentRect, anchorRect, floatingRect);
+    const settings = {
+      anchorOffset: 4
+    };
+    const {
+      top,
+      left
+    } = getAnchoredPosition(float, anchor, settings);
+    expect(top).toEqual(234);
+    expect(left).toEqual(280);
+  });
+  it('returns the correct position for different outside side settings with no overflow', () => {
+    const parentRect = makeDOMRect(20, 20, 500, 500);
+    const anchorRect = makeDOMRect(300, 200, 50, 50);
+    const floatingRect = makeDOMRect(NaN, NaN, 100, 100);
+    const {
+      float,
+      anchor
+    } = createVirtualDOM(parentRect, anchorRect, floatingRect);
+    const settings = {};
+    let top = 0;
+    let left = 0; // should be the same calculation as the default settings test above
+
+    settings.side = 'outside-bottom';
+    ({
+      top,
+      left
+    } = getAnchoredPosition(float, anchor, settings));
+    expect(top).toEqual(234); // anchorRect.top + anchorRect.height + (settings.anchorOffset ?? 4) - parentRect.top
+
+    expect(left).toEqual(280); // anchorRect.left - parentRect.left
+
+    settings.side = 'outside-left';
+    ({
+      top,
+      left
+    } = getAnchoredPosition(float, anchor, settings));
+    expect(top).toEqual(180); // anchorRect.top - parentRect.top
+
+    expect(left).toEqual(176); // anchorRect.left - floatingRect.width - (settings.anchorOffset ?? 4) - parentRect.left
+
+    settings.side = 'outside-right';
+    ({
+      top,
+      left
+    } = getAnchoredPosition(float, anchor, settings));
+    expect(top).toEqual(180); // anchorRect.top - parentRect.top
+
+    expect(left).toEqual(334); // anchorRect.left + anchorRect.width + (settings.anchorOffset ?? 4) - parentRect.left
+
+    settings.side = 'outside-top';
+    ({
+      top,
+      left
+    } = getAnchoredPosition(float, anchor, settings));
+    expect(top).toEqual(76); // anchorRect.top - floatingRect.height - (settings.anchorOffset ?? 4) - parentRect.top
+
+    expect(left).toEqual(280); // anchorRect.left - parentRect.left
+  });
+  it('returns the correct position for different inside side settings', () => {
+    const parentRect = makeDOMRect(20, 20, 500, 500);
+    const anchorRect = makeDOMRect(300, 200, 50, 50);
+    const floatingRect = makeDOMRect(NaN, NaN, 100, 100);
+    const {
+      float,
+      anchor
+    } = createVirtualDOM(parentRect, anchorRect, floatingRect);
+    const settings = {};
+    let top = 0;
+    let left = 0;
+    settings.side = 'inside-bottom';
+    ({
+      top,
+      left
+    } = getAnchoredPosition(float, anchor, settings)); // anchorRect.top + anchorRect.height - (settings.anchorOffset ?? 4) - floatingRect.height - parentRect.top
+
+    expect(top).toEqual(126); // anchorRect.left + (settings.alignmentOffset ?? 4) - parentRect.left
+
+    expect(left).toEqual(284);
+    settings.side = 'inside-left';
+    ({
+      top,
+      left
+    } = getAnchoredPosition(float, anchor, settings));
+    expect(top).toEqual(184); // anchorRect.top + (settings.alignmentOffset ?? 4) - parentRect.top
+
+    expect(left).toEqual(284); // anchorRect.left + (settings.anchorOffset ?? 4) - parentRect.left
+
+    settings.side = 'inside-right';
+    ({
+      top,
+      left
+    } = getAnchoredPosition(float, anchor, settings)); // anchorRect.top + (settings.alignmentOffset ?? 4) - parentRect.top
+
+    expect(top).toEqual(184); // anchorRect.left + anchorRect.width - (settings.anchorOffset ?? 4) - floatingRect.width - parentRect.left
+
+    expect(left).toEqual(226); // almost the same as inside-left, with the exception of offsets
+
+    settings.side = 'inside-top';
+    ({
+      top,
+      left
+    } = getAnchoredPosition(float, anchor, settings));
+    expect(top).toEqual(184); // anchorRect.top + (settings.anchorOffset ?? 4) - parentRect.top
+
+    expect(left).toEqual(284); // anchorRect.left + (settings.alignmentOffset ?? 4) - parentRect.left
+
+    settings.side = 'inside-center';
+    ({
+      top,
+      left
+    } = getAnchoredPosition(float, anchor, settings));
+    expect(top).toEqual(184); // anchorRect.top + (settings.alignmentOffset ?? 4) - parentRect.top
+
+    expect(left).toEqual(255); // anchorRect.left + anchorRect.width / 2 - floatingRect.width / 2 - parentRect.left
+  });
+  it('returns the correct position inside centering along both axes', () => {
+    const parentRect = makeDOMRect(20, 20, 500, 500);
+    const anchorRect = makeDOMRect(300, 200, 50, 50);
+    const floatingRect = makeDOMRect(NaN, NaN, 100, 100);
+    const {
+      float,
+      anchor
+    } = createVirtualDOM(parentRect, anchorRect, floatingRect);
+    const settings = {
+      side: 'inside-center',
+      align: 'center'
+    };
+    const {
+      top,
+      left
+    } = getAnchoredPosition(float, anchor, settings);
+    expect(top).toEqual(155); // anchorRect.top + anchorRect.height / 2 - floatingRect.height / 2 - parentRect.top
+
+    expect(left).toEqual(255); // anchorRect.left + anchorRect.width / 2 - floatingRect.width / 2 - parentRect.left
+  });
+  it('returns the correct position for different alignment settings with no overflow', () => {
+    const parentRect = makeDOMRect(20, 20, 500, 500);
+    const anchorRect = makeDOMRect(300, 200, 50, 50);
+    const floatingRect = makeDOMRect(NaN, NaN, 100, 100);
+    const {
+      float,
+      anchor
+    } = createVirtualDOM(parentRect, anchorRect, floatingRect);
+    const settings = {};
+    let top = 0;
+    let left = 0;
+    settings.align = 'start';
+    ({
+      top,
+      left
+    } = getAnchoredPosition(float, anchor, settings));
+    expect(top).toEqual(234); // anchorRect.top + anchorRect.height + (settings.anchorOffset ?? 4) - parentRect.top
+
+    expect(left).toEqual(280); // anchorRect.left + (settings.alignmentOffset ?? 0) - parentRect.left
+
+    settings.align = 'center';
+    ({
+      top,
+      left
+    } = getAnchoredPosition(float, anchor, settings)); // anchorRect.top + anchorRect.height + (settings.anchorOffset ?? 4) - parentRect.top
+
+    expect(top).toEqual(234); // anchorRect.left + anchorRect.width / 2 - floatingRect.width / 2 + (settings.anchorOffset ?? 0) - parentRect.left
+
+    expect(left).toEqual(255);
+    settings.align = 'end';
+    ({
+      top,
+      left
+    } = getAnchoredPosition(float, anchor, settings)); // anchorRect.top + anchorRect.height + (settings.anchorOffset ?? 4) - parentRect.top
+
+    expect(top).toEqual(234); // anchorRect.left + anchorRect.width - floatingRect.width - (settings.alignmentOffset ?? 0) - parentRect.left
+
+    expect(left).toEqual(230);
+  });
+  it('properly flips to the opposite side if the calculated position overflows along the same axis', () => {
+    const parentRect = makeDOMRect(20, 20, 500, 500);
+    const anchorRect = makeDOMRect(300, 400, 50, 50);
+    const floatingRect = makeDOMRect(NaN, NaN, 100, 100);
+    const {
+      float,
+      anchor
+    } = createVirtualDOM(parentRect, anchorRect, floatingRect);
+    const settings = {};
+    const {
+      top,
+      left
+    } = getAnchoredPosition(float, anchor, settings);
+    expect(top).toEqual(276); // anchorRect.top - floatingRect.height - (settings.anchorOffset ?? 4) - parentRect.top
+
+    expect(left).toEqual(280); // anchorRect.left - parentRect.left
+  });
+  it('properly moves to an adjacent side if overflow happens along side edge and flipped edge', () => {
+    const parentRect = makeDOMRect(20, 20, 500, 200);
+    const anchorRect = makeDOMRect(300, 100, 50, 50);
+    const floatingRect = makeDOMRect(NaN, NaN, 100, 100);
+    const {
+      float,
+      anchor
+    } = createVirtualDOM(parentRect, anchorRect, floatingRect);
+    const settings = {};
+    const {
+      top,
+      left
+    } = getAnchoredPosition(float, anchor, settings);
+    expect(top).toEqual(80); // anchorRect.top - parentRect.top
+
+    expect(left).toEqual(334); // anchorRect.left + anchorRect.width + (settings.anchorOffset ?? 4) - parentRect.left
+  });
+  it('properly adjusts the position using an alignment offset if overflow happens along the alignment edge', () => {
+    const parentRect = makeDOMRect(20, 20, 500, 500);
+    const anchorRect = makeDOMRect(300, 200, 50, 50);
+    const floatingRect = makeDOMRect(NaN, NaN, 400, 100);
+    const {
+      float,
+      anchor
+    } = createVirtualDOM(parentRect, anchorRect, floatingRect);
+    const settings = {};
+    const {
+      top,
+      left
+    } = getAnchoredPosition(float, anchor, settings);
+    expect(top).toEqual(234); // anchorRect.top + anchorRect.height + (settings.anchorOffset ?? 4) - parentRect.top
+
+    expect(left).toEqual(100); // parentRect.width - floatingRect.width
+  });
+  it('properly calculates the position that needs to be flipped and offset-adjusted', () => {
+    const parentRect = makeDOMRect(20, 20, 500, 500);
+    const anchorRect = makeDOMRect(300, 400, 50, 50);
+    const floatingRect = makeDOMRect(NaN, NaN, 400, 100);
+    const {
+      float,
+      anchor
+    } = createVirtualDOM(parentRect, anchorRect, floatingRect);
+    const settings = {};
+    const {
+      top,
+      left
+    } = getAnchoredPosition(float, anchor, settings);
+    expect(top).toEqual(276); // anchorRect.top - floatingRect.height - (settings.anchorOffset ?? 4) - parentRect.top
+
+    expect(left).toEqual(100); // parentRect.width - floatingRect.width
+  });
+  it('properly calculates the outside position with many simultaneous settings interactions (stress test)', () => {
+    const parentRect = makeDOMRect(20, 20, 200, 500);
+    const anchorRect = makeDOMRect(95, 295, 100, 200);
+    const floatingRect = makeDOMRect(NaN, NaN, 175, 200);
+    const {
+      float,
+      anchor
+    } = createVirtualDOM(parentRect, anchorRect, floatingRect);
+    const settings = {
+      side: 'outside-right',
+      align: 'center',
+      alignmentOffset: 10,
+      anchorOffset: -10
+    };
+    const {
+      top,
+      left
+    } = getAnchoredPosition(float, anchor, settings); // expect to try right, left, and bottom before ending on top
+
+    expect(top).toEqual(85); // anchorRect.top - floatingRect.height - (settings.anchorOffset ?? 4) - parentRect.top
+    // expect center alignment to run against edge, so ignored. Also causes alignment offset to be ignored.
+
+    expect(left).toEqual(25); // parentRect.width - floatingRect.width
+  });
+  it('properly calculates the inside position with many simultaneous settings interactions (stress test)', () => {
+    const parentRect = makeDOMRect(20, 20, 500, 500);
+    const anchorRect = makeDOMRect(100, 100, 300, 300);
+    const floatingRect = makeDOMRect(NaN, NaN, 100, 200);
+    const {
+      float,
+      anchor
+    } = createVirtualDOM(parentRect, anchorRect, floatingRect);
+    const settings = {
+      side: 'inside-right',
+      align: 'center',
+      alignmentOffset: 10,
+      anchorOffset: -10
+    };
+    const {
+      top,
+      left
+    } = getAnchoredPosition(float, anchor, settings); // anchorRect.top + anchorRect.height / 2 - floatingRect.height / 2 + (settings.alignmentOffset ?? 4) - parentRect.top
+
+    expect(top).toEqual(140); // anchorRect.left + anchorRect.width - floatingRect.width - (settings.anchorOffset ?? 4) - parentRect.left
+
+    expect(left).toEqual(290);
+  });
+});

package/lib-esm/__tests__/behaviors/focusTrap.test.d.ts

@@ -0,0 +1 @@
+export {};