@primer/components 31.0.2-rc.c7dafefb → 31.2.0-rc.a53b3afb

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

@@ -2,7 +2,7 @@ function _extends() { _extends = Object.assign || function (target) { for (var i
 
 import React from 'react';
 import { render } from '../utils/testing';
-import { render as HTMLRender, cleanup, fireEvent } from '@testing-library/react';
+import { render as HTMLRender, fireEvent, act, cleanup } from '@testing-library/react';
 import { axe, toHaveNoViolations } from 'jest-axe';
 import 'babel-polyfill';
 import { tokenSizes } from '../Token/TokenBase';
@@ -46,8 +46,18 @@ const LabelledTextInputWithTokens = ({
   tokens: tokens,
   onTokenRemove: onTokenRemove,
   id: "tokenInput"
-}, rest)));
+}, rest))); // describe('axe test', () => {
+//   it('should have no axe violations', async () => {
+//     const onRemoveMock = jest.fn()
+//     const {container} = HTMLRender(<LabelledTextInputWithTokens tokens={mockTokens} onTokenRemove={onRemoveMock} />)
+//     const results = await axe(container)
+//     expect(results).toHaveNoViolations()
+//     cleanup()
+//   })
+// })
 
+
+jest.useFakeTimers();
 describe('TextInputWithTokens', () => {
   it('renders without tokens', () => {
     const onRemoveMock = jest.fn();
@@ -115,6 +125,14 @@ describe('TextInputWithTokens', () => {
       onTokenRemove: onRemoveMock
     }))).toMatchSnapshot();
   });
+  it('renders a truncated set of tokens', () => {
+    const onRemoveMock = jest.fn();
+    expect(render( /*#__PURE__*/React.createElement(TextInputWithTokens, {
+      tokens: mockTokens,
+      onTokenRemove: onRemoveMock,
+      visibleTokenCount: 2
+    }))).toMatchSnapshot();
+  });
   it('focuses the previous token when keying ArrowLeft', () => {
     var _document$activeEleme, _document$activeEleme2;
 
@@ -220,8 +238,123 @@ describe('TextInputWithTokens', () => {
     expect((_document$activeEleme8 = document.activeElement) === null || _document$activeEleme8 === void 0 ? void 0 : _document$activeEleme8.id).not.toEqual(lastTokenNode.id);
     expect((_document$activeEleme9 = document.activeElement) === null || _document$activeEleme9 === void 0 ? void 0 : _document$activeEleme9.id).toEqual(inputNode.id);
   });
+  it('does not focus the input when clicking a token', () => {
+    var _document$activeEleme10;
+
+    const onRemoveMock = jest.fn();
+    const {
+      getByLabelText,
+      getByText
+    } = HTMLRender( /*#__PURE__*/React.createElement(LabelledTextInputWithTokens, {
+      tokens: mockTokens,
+      onTokenRemove: onRemoveMock,
+      visibleTokenCount: 2
+    }));
+    const inputNode = getByLabelText('Tokens');
+    const tokenNode = getByText(mockTokens[0].text);
+    expect(document.activeElement).not.toEqual(inputNode.id);
+    fireEvent.click(tokenNode);
+    expect((_document$activeEleme10 = document.activeElement) === null || _document$activeEleme10 === void 0 ? void 0 : _document$activeEleme10.id).not.toEqual(inputNode.id);
+  });
+  it('focuses the input when clicking somewhere in the component besides the tokens', () => {
+    var _document$activeEleme11;
+
+    const onRemoveMock = jest.fn();
+    const {
+      getByLabelText,
+      getByText
+    } = HTMLRender( /*#__PURE__*/React.createElement(LabelledTextInputWithTokens, {
+      tokens: mockTokens,
+      onTokenRemove: onRemoveMock,
+      visibleTokenCount: 2
+    }));
+    const inputNode = getByLabelText('Tokens');
+    const truncatedTokenCount = getByText('+6');
+    expect(document.activeElement).not.toEqual(inputNode.id);
+    fireEvent.click(truncatedTokenCount);
+    expect((_document$activeEleme11 = document.activeElement) === null || _document$activeEleme11 === void 0 ? void 0 : _document$activeEleme11.id).toEqual(inputNode.id);
+  });
+  it('shows all tokens when the input is focused and hides them when it is blurred (when visibleTokenCount is set)', () => {
+    const onRemoveMock = jest.fn();
+    const visibleTokenCount = 2;
+    const {
+      getByLabelText,
+      getByText
+    } = HTMLRender( /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(LabelledTextInputWithTokens, {
+      tokens: mockTokens,
+      onTokenRemove: onRemoveMock,
+      visibleTokenCount: visibleTokenCount
+    }), /*#__PURE__*/React.createElement("button", {
+      id: "focusableOutsideComponent"
+    }, "Focus me")));
+    const inputNode = getByLabelText('Tokens');
+    const focusableOutsideComponentNode = getByText('Focus me');
+    const allTokenLabels = mockTokens.map(token => token.text);
+    const truncatedTokenCountNode = getByText('+6');
+    act(() => {
+      jest.runAllTimers();
+      fireEvent.focus(inputNode);
+    });
+    setTimeout(() => {
+      for (const tokenLabel of allTokenLabels) {
+        const tokenNode = getByText(tokenLabel);
+        expect(tokenNode).toBeDefined();
+      }
+    }, 0);
+    act(() => {
+      jest.runAllTimers(); // onBlur isn't called on input unless we specifically fire the "blur" event
+      // eslint-disable-next-line github/no-blur
+
+      fireEvent.blur(inputNode);
+      fireEvent.focus(focusableOutsideComponentNode);
+    });
+    setTimeout(() => {
+      expect(truncatedTokenCountNode).toBeDefined();
+
+      for (const tokenLabel of allTokenLabels) {
+        const tokenNode = getByText(tokenLabel);
+
+        if (allTokenLabels.indexOf(tokenLabel) > visibleTokenCount) {
+          // eslint-disable-next-line jest/no-conditional-expect
+          expect(tokenNode).toBeDefined();
+        } else {
+          // eslint-disable-next-line jest/no-conditional-expect
+          expect(tokenNode).not.toBeDefined();
+        }
+      }
+    }, 0);
+    jest.useRealTimers();
+  });
+  it('does not hide tokens when blurring the input to focus within the component (when visibleTokenCount is set)', () => {
+    const onRemoveMock = jest.fn();
+    const visibleTokenCount = 2;
+    const {
+      getByLabelText,
+      getByText
+    } = HTMLRender( /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(LabelledTextInputWithTokens, {
+      tokens: mockTokens,
+      onTokenRemove: onRemoveMock,
+      visibleTokenCount: visibleTokenCount
+    }), /*#__PURE__*/React.createElement("button", {
+      id: "focusableOutsideComponent"
+    }, "Focus me")));
+    const inputNode = getByLabelText('Tokens');
+    const firstTokenNode = getByText(mockTokens[visibleTokenCount - 1].text);
+    const allTokenLabels = mockTokens.map(token => token.text);
+    const truncatedTokenCountNode = getByText('+6');
+    act(() => {
+      fireEvent.focus(inputNode);
+      fireEvent.focus(firstTokenNode);
+    });
+    expect(truncatedTokenCountNode).toBeDefined();
+
+    for (const tokenLabel of allTokenLabels) {
+      const tokenNode = getByText(tokenLabel);
+      expect(tokenNode).toBeDefined();
+    }
+  });
   it('focuses the first token when keying ArrowRight in the input', () => {
-    var _document$activeEleme10, _document$activeEleme11;
+    var _document$activeEleme12, _document$activeEleme13;
 
     const onRemoveMock = jest.fn();
     const {
@@ -238,8 +371,8 @@ describe('TextInputWithTokens', () => {
     fireEvent.keyDown(inputNode, {
       key: 'ArrowRight'
     });
-    expect((_document$activeEleme10 = document.activeElement) === null || _document$activeEleme10 === void 0 ? void 0 : _document$activeEleme10.id).not.toEqual(inputNode.id);
-    expect((_document$activeEleme11 = document.activeElement) === null || _document$activeEleme11 === void 0 ? void 0 : _document$activeEleme11.id).toEqual(firstTokenNode.id);
+    expect((_document$activeEleme12 = document.activeElement) === null || _document$activeEleme12 === void 0 ? void 0 : _document$activeEleme12.id).not.toEqual(inputNode.id);
+    expect((_document$activeEleme13 = document.activeElement) === null || _document$activeEleme13 === void 0 ? void 0 : _document$activeEleme13.id).toEqual(firstTokenNode.id);
   });
   it('calls onTokenRemove on the last token when keying Backspace in an empty input', () => {
     const onRemoveMock = jest.fn();
@@ -324,9 +457,9 @@ describe('TextInputWithTokens', () => {
     });
     jest.runAllTimers();
     setTimeout(() => {
-      var _document$activeEleme12;
+      var _document$activeEleme14;
 
-      expect((_document$activeEleme12 = document.activeElement) === null || _document$activeEleme12 === void 0 ? void 0 : _document$activeEleme12.textContent).toBe(mockTokens[1].text);
+      expect((_document$activeEleme14 = document.activeElement) === null || _document$activeEleme14 === void 0 ? void 0 : _document$activeEleme14.textContent).toBe(mockTokens[1].text);
     }, 0);
     jest.useRealTimers();
   });
@@ -348,9 +481,9 @@ describe('TextInputWithTokens', () => {
     });
     jest.runAllTimers();
     setTimeout(() => {
-      var _document$activeEleme13;
+      var _document$activeEleme15;
 
-      expect((_document$activeEleme13 = document.activeElement) === null || _document$activeEleme13 === void 0 ? void 0 : _document$activeEleme13.id).toBe(inputNode.id);
+      expect((_document$activeEleme15 = document.activeElement) === null || _document$activeEleme15 === void 0 ? void 0 : _document$activeEleme15.id).toBe(inputNode.id);
     }, 0);
     jest.useRealTimers();
   });

package/lib-esm/stories/TextInputWithTokens.stories.js

@@ -171,6 +171,20 @@ export const TokenRemoveButtonsHidden = () => {
   });
 };
 TokenRemoveButtonsHidden.displayName = "TokenRemoveButtonsHidden";
+export const WithVisibleTokenCount = () => {
+  const [tokens, setTokens] = useState([...mockTokens].slice(0, 5));
+
+  const onTokenRemove = tokenId => {
+    setTokens(tokens.filter(token => token.id !== tokenId));
+  };
+
+  return /*#__PURE__*/React.createElement(TextInputWithTokens, {
+    tokens: tokens,
+    onTokenRemove: onTokenRemove,
+    visibleTokenCount: 2
+  });
+};
+WithVisibleTokenCount.displayName = "WithVisibleTokenCount";
 export const Unstyled = () => {
   const [tokens, setTokens] = useState([...mockTokens].slice(0, 2));
 

package/lib-esm/sx.d.ts

@@ -1,6 +1,12 @@
-import { SystemStyleObject } from '@styled-system/css';
+import { SystemCssProperties, SystemStyleObject } from '@styled-system/css';
+import { ThemeColorPaths, ThemeShadowPaths } from './theme';
+import { ColorProps, ShadowProps } from 'styled-system';
+export declare type BetterCssProperties = {
+    [K in keyof SystemCssProperties]: K extends keyof ColorProps ? ThemeColorPaths | SystemCssProperties[K] : K extends keyof ShadowProps ? ThemeShadowPaths | SystemCssProperties[K] : SystemCssProperties[K];
+};
+export declare type BetterSystemStyleObject = BetterCssProperties | SystemStyleObject;
 export interface SxProp {
-    sx?: SystemStyleObject;
+    sx?: BetterSystemStyleObject;
 }
 declare const sx: (props: SxProp) => import("@styled-system/css").CssFunctionReturnType;
 export default sx;

package/lib-esm/theme.d.ts

@@ -1,2 +1,80 @@
 import { theme } from './theme-preval';
+import { KeyPaths } from './utils/types/KeyPaths';
 export default theme;
+declare type ThemeColors = {
+    fg: {
+        default: string;
+        muted: string;
+        subtle: string;
+        onEmphasis: string;
+    };
+    canvas: {
+        default: string;
+        overlay: string;
+        inset: string;
+        subtle: string;
+    };
+    border: {
+        default: string;
+        muted: string;
+        subtle: string;
+    };
+    neutral: {
+        emphasisPlus: string;
+        emphasis: string;
+        muted: string;
+        subtle: string;
+    };
+    accent: {
+        fg: string;
+        emphasis: string;
+        muted: string;
+        subtle: string;
+    };
+    success: {
+        fg: string;
+        emphasis: string;
+        muted: string;
+        subtle: string;
+    };
+    attention: {
+        fg: string;
+        emphasis: string;
+        muted: string;
+        subtle: string;
+    };
+    severe: {
+        fg: string;
+        emphasis: string;
+        muted: string;
+        subtle: string;
+    };
+    danger: {
+        fg: string;
+        emphasis: string;
+        muted: string;
+        subtle: string;
+    };
+    done: {
+        fg: string;
+        emphasis: string;
+        muted: string;
+        subtle: string;
+    };
+    sponsors: {
+        fg: string;
+        emphasis: string;
+        muted: string;
+        subtle: string;
+    };
+};
+declare type ThemeShadows = {
+    shadow: {
+        small: string;
+        medium: string;
+        large: string;
+        extraLarge: string;
+    };
+};
+export declare type ThemeColorPaths = KeyPaths<ThemeColors>;
+export declare type ThemeShadowPaths = KeyPaths<ThemeShadows>;

package/lib-esm/theme.js

@@ -1,2 +1,3 @@
 import { theme } from './theme-preval';
-export default theme;
+export default theme; // NOTE: for now, ThemeColors and ThemeShadows are handcrafted types. It would be nice if these
+// were exports from primitives (or a different shape but derived from those exports).

package/lib-esm/utils/types/KeyPaths.d.ts

@@ -0,0 +1,3 @@
+export declare type KeyPaths<O extends Record<string, unknown>> = {
+    [K in keyof O]: K extends string ? (O[K] extends string ? `${K}` : `${K}.${KeyPaths<O[K]>}`) : never;
+}[keyof O];

package/lib-esm/utils/types/KeyPaths.js

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