@transferwise/components 0.0.0-experimental-033dd15 → 0.0.0-experimental-a41b256

package/src/upload/Upload.spec.tsx

@@ -0,0 +1,295 @@
+import { render, fireEvent, waitFor, screen } from '../test-utils';
+import { act } from 'react';
+import Upload from '.';
+import { asyncFileRead } from './utils/asyncFileRead';
+import { postData } from './utils/postData';
+
+jest.mock('./utils/asyncFileRead');
+jest.mock('./utils/postData');
+
+const TEST_FILE = new File(['test content'], 'test.png', { type: 'image/png' });
+const INVALID_FILE = new File(['invalid content'], 'invalid.txt', { type: 'text/plain' });
+
+beforeAll(() => {
+  class MockDataTransfer {
+    items: { add: (file: File) => void };
+    files: File[];
+
+    constructor() {
+      this.items = {
+        add: (file: File) => {
+          this.files.push(file);
+        },
+      };
+      this.files = [];
+    }
+  }
+
+  // @ts-expect-error: Mocking global DataTransfer for testing purposes
+  global.DataTransfer = MockDataTransfer;
+});
+
+describe('Upload Component', () => {
+  const props = {
+    animationDelay: 100,
+    csButtonText: 'csButtonText',
+    csFailureText: 'csFailureText',
+    csSuccessText: 'csSuccessText',
+    csTooLargeMessage: 'csTooLargeMessage',
+    maxSize: 5000000,
+    onCancel: jest.fn(),
+    onChange: jest.fn(),
+    onFailure: jest.fn(),
+    onStart: jest.fn(),
+    onSuccess: jest.fn(),
+    psButtonText: 'psButtonText',
+    psProcessingText: 'psProcessingText',
+    usAccept: 'image/*',
+    usButtonText: 'Or Select File',
+    usButtonRetryText: 'Try again',
+    usDropMessage: 'Drop file to start upload',
+    usPlaceholder: 'Drag and drop a file less than 5MB',
+  };
+
+  const waitForUpload = async () => {
+    for (let i = 0; i < 4; i += 1) {
+      await act(async () => {
+        await jest.runOnlyPendingTimersAsync();
+      });
+    }
+  };
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    (asyncFileRead as jest.Mock).mockImplementation(async () => 'a value');
+    (postData as jest.Mock).mockResolvedValue('ServerResponse');
+    Object.defineProperty(window, 'matchMedia', {
+      writable: true,
+      value: jest.fn().mockImplementation((query: string) => ({
+        matches: false,
+        media: query,
+        onchange: null,
+        addListener: jest.fn(),
+        removeListener: jest.fn(),
+        addEventListener: jest.fn(),
+        removeEventListener: jest.fn(),
+        dispatchEvent: jest.fn(),
+      })),
+    });
+  });
+
+  afterEach(async () => {
+    await jest.runOnlyPendingTimersAsync();
+    jest.runOnlyPendingTimers();
+    jest.useRealTimers();
+  });
+
+  test('adds droppable-dropping class on dragenter', async () => {
+    const { container } = render(<Upload {...props} />);
+    const droppableElement = await waitFor(() => container.querySelector('.droppable-area'));
+    expect(droppableElement).toBeTruthy();
+
+    fireEvent.dragEnter(droppableElement!, { dataTransfer: new DataTransfer() });
+
+    await waitFor(() => {
+      expect(droppableElement).toHaveClass('droppable-dropping');
+    });
+  });
+
+  test('removes droppable-dropping class on dragleave', async () => {
+    const { container } = render(<Upload {...props} />);
+    const droppableElement = await waitFor(() => container.querySelector('.droppable-area'));
+    expect(droppableElement).toBeTruthy();
+
+    fireEvent.dragEnter(droppableElement!, { dataTransfer: new DataTransfer() });
+
+    await waitFor(() => {
+      expect(droppableElement).toHaveClass('droppable-dropping');
+    });
+
+    fireEvent.dragLeave(droppableElement!);
+
+    await waitFor(() => {
+      expect(droppableElement).not.toHaveClass('droppable-dropping');
+    });
+  });
+
+  test('adds droppable-processing when file is dropped', async () => {
+    const { container } = render(<Upload {...props} />);
+    const droppableElement = await waitFor(() => container.querySelector('.droppable-area'));
+
+    const dataTransfer = new DataTransfer();
+    dataTransfer.items.add(TEST_FILE);
+
+    fireEvent.drop(droppableElement!, { dataTransfer });
+
+    await waitFor(() => expect(droppableElement).toHaveClass('droppable-processing'));
+  });
+
+  test('should handle successful file upload', async () => {
+    (asyncFileRead as jest.Mock).mockResolvedValue('mockBase64Image');
+    (postData as jest.Mock).mockResolvedValue('mockSuccessResponse');
+
+    const { container } = render(<Upload {...props} />);
+
+    await act(async () => {
+      const droppableElement = await waitFor(() => container.querySelector('.droppable-area'));
+
+      const dataTransfer = new DataTransfer();
+      dataTransfer.items.add(TEST_FILE);
+      fireEvent.drop(droppableElement!, { dataTransfer });
+    });
+
+    await act(async () => {
+      jest.advanceTimersByTime(10);
+      jest.advanceTimersByTime(props.animationDelay);
+    });
+
+    expect(await screen.findByText(/csSuccessText/i)).toBeInTheDocument();
+  });
+
+  test('should handle file size exceeding the limit', async () => {
+    const largeFile = new File(['large '.repeat(1000000)], 'large.jpg', { type: 'image/jpeg' });
+    const { container } = render(<Upload {...props} maxSize={10} />);
+
+    await act(async () => {
+      const droppableElement = await waitFor(() => container.querySelector('.droppable-area'));
+      const dataTransfer = new DataTransfer();
+      dataTransfer.items.add(largeFile);
+      fireEvent.drop(droppableElement!, { dataTransfer });
+    });
+
+    await act(async () => {
+      jest.advanceTimersByTime(1000);
+      jest.advanceTimersByTime(props.animationDelay);
+    });
+
+    await waitForUpload();
+
+    expect(await screen.findByText(/csTooLargeMessage/i)).toBeInTheDocument();
+  });
+
+  test('should handle invalid file type', async () => {
+    (postData as jest.Mock).mockRejectedValue(new Error('mockErrorResponse'));
+
+    const { container } = render(<Upload {...props} />);
+
+    await act(async () => {
+      const droppableElement = await waitFor(() => container.querySelector('.droppable-area'));
+
+      const dataTransfer = new DataTransfer();
+      dataTransfer.items.add(INVALID_FILE);
+      fireEvent.drop(droppableElement!, { dataTransfer });
+    });
+
+    await waitForUpload();
+
+    expect(
+      await screen.findByText(/File type not supported. Please try again with a different file/i),
+    ).toBeInTheDocument();
+  });
+
+  test('should handle canceling the upload', async () => {
+    const { container } = render(<Upload {...props} />);
+
+    await act(async () => {
+      const droppableElement = await waitFor(() => container.querySelector('.droppable-area'));
+
+      const dataTransfer = new DataTransfer();
+      dataTransfer.items.add(TEST_FILE);
+      fireEvent.drop(droppableElement!, { dataTransfer });
+    });
+
+    fireEvent.click(await screen.findByText(/csButtonText/i));
+
+    expect(props.onCancel).toHaveBeenCalled();
+  });
+
+  test('should handle retrying the upload', async () => {
+    (asyncFileRead as jest.Mock).mockRejectedValueOnce('error');
+
+    const { container } = render(<Upload {...props} />);
+
+    await act(async () => {
+      const droppableElement = await waitFor(() => container.querySelector('.droppable-area'));
+
+      const dataTransfer = new DataTransfer();
+      dataTransfer.items.add(TEST_FILE);
+      fireEvent.drop(droppableElement!, { dataTransfer });
+    });
+
+    await waitForUpload();
+
+    fireEvent.click(await screen.findByText(/Try again/i));
+
+    expect(props.onStart).toHaveBeenCalled();
+  });
+
+  test('should call onSuccess with the server response when httpOptions are provided', async () => {
+    (asyncFileRead as jest.Mock).mockResolvedValue('mockBase64Image');
+    (postData as jest.Mock).mockResolvedValue('mockServerResponse');
+
+    const { container } = render(<Upload {...props} httpOptions={{ url: 'test-url' }} />);
+    const droppableElement = await waitFor(() => container.querySelector('.droppable-area'));
+
+    const dataTransfer = new DataTransfer();
+    dataTransfer.items.add(TEST_FILE);
+
+    await act(async () => {
+      fireEvent.drop(droppableElement!, { dataTransfer });
+    });
+
+    await waitForUpload();
+
+    expect(props.onSuccess).toHaveBeenCalledWith('mockServerResponse', TEST_FILE.name);
+  });
+
+  test('should not allow new file to process while current one is in progress', async () => {
+    (asyncFileRead as jest.Mock).mockResolvedValue('someResult');
+
+    const { container } = render(<Upload {...props} httpOptions={{ url: 'test-url' }} />);
+    const droppableElement = await waitFor(() => container.querySelector('.droppable-area'));
+
+    const dataTransfer = new DataTransfer();
+    dataTransfer.items.add(TEST_FILE);
+
+    await act(async () => {
+      fireEvent.drop(droppableElement!, { dataTransfer });
+    });
+
+    const secondFileDataTransfer = new DataTransfer();
+    secondFileDataTransfer.items.add(TEST_FILE);
+
+    let dropResult = true;
+    await act(async () => {
+      try {
+        fireEvent.drop(droppableElement!, { dataTransfer: secondFileDataTransfer });
+      } catch {
+        dropResult = false;
+      }
+    });
+
+    expect(dropResult).toBe(true);
+  });
+
+  test('should override the error icon label when errorIconLabel prop is provided', async () => {
+    (asyncFileRead as jest.Mock).mockRejectedValueOnce('mockReadError');
+    (postData as jest.Mock).mockRejectedValueOnce(new Error('mockPostError'));
+
+    const customLabel = 'Custom error label';
+    const { container } = render(<Upload {...props} errorIconLabel={customLabel} />);
+    const droppableElement = await waitFor(() => container.querySelector('.droppable-area'));
+
+    const dataTransfer = new DataTransfer();
+    dataTransfer.items.add(TEST_FILE);
+
+    await act(async () => {
+      fireEvent.drop(droppableElement!, { dataTransfer });
+    });
+
+    await waitForUpload();
+
+    const errorIcon = await screen.findByLabelText(/Custom error label/i);
+    expect(errorIcon).toBeInTheDocument();
+  });
+});

package/src/upload/Upload.tsx

@@ -172,7 +172,11 @@ export class Upload extends Component<UploadProps, UploadState> {
             isProcessing: false,
             isComplete: true,
           },
-          onSuccess ? () => onSuccess(response as string | Response, fileName) : undefined,
+          onSuccess
+            ? () => {
+                onSuccess(response as string | Response, fileName);
+              }
+            : undefined,
         );
       }, animationDelay);
     }

package/src/upload/steps/completeStep/completeStep.spec.tsx

@@ -0,0 +1,51 @@
+import { render, fireEvent, waitFor, screen } from '../../../test-utils';
+
+import CompleteStep from '.';
+
+describe('CompleteStep', () => {
+  const COMPLETED_STEP_PROPS = {
+    isComplete: true,
+    uploadedImage: '',
+    fileName: 'fileName',
+    isError: false,
+    isImage: true,
+    csSuccessText: 'csSuccessText',
+    csFailureText: 'csFailureText',
+    csButtonText: 'csButtonText',
+    onClear: jest.fn(),
+    usLabel: 'usLabel',
+  };
+
+  let container: HTMLElement;
+
+  beforeEach(() => {
+    const view = render(<CompleteStep {...COMPLETED_STEP_PROPS} />);
+    container = view.container;
+  });
+
+  test('renders container', async () => {
+    await waitFor(() => {
+      const complete = container.querySelector('.droppable-complete-card');
+      expect(complete).toBeInTheDocument();
+    });
+  });
+
+  describe('when error is false', () => {
+    test('renders isImage or Upload icon', () => {
+      expect(screen.getByTestId('document-icon')).toBeInTheDocument();
+    });
+
+    test('renders filename when error is false', () => {
+      expect(screen.getByText(COMPLETED_STEP_PROPS.fileName)).toBeInTheDocument();
+    });
+  });
+
+  test('renders button when csButtonText is set up', () => {
+    expect(screen.getByText(COMPLETED_STEP_PROPS.csButtonText)).toBeInTheDocument();
+  });
+
+  test('calls onClear when button is clicked', () => {
+    fireEvent.click(screen.getByText(COMPLETED_STEP_PROPS.csButtonText));
+    expect(COMPLETED_STEP_PROPS.onClear).toHaveBeenCalledTimes(1);
+  });
+});

package/src/upload/steps/completeStep/completeStep.tsx

@@ -1,6 +1,6 @@
 import { Document as DocumentIcon } from '@transferwise/icons';
 
-import { Typography } from '../../..';
+import { Typography } from '../../../common';
 import Body from '../../../body';
 import Button from '../../../button';
 import Title from '../../../title';

package/src/upload/steps/processingStep/processingStep.spec.tsx

@@ -0,0 +1,59 @@
+import { render, fireEvent, waitFor, screen } from '../../../test-utils';
+
+import ProcessingStep from '.';
+
+describe('ProcessingStep', () => {
+  const PROCESSING_STEP_PROPS = {
+    isComplete: false,
+    isError: false,
+    isSuccess: false,
+    onAnimationCompleted: jest.fn(),
+    onClear: jest.fn(),
+    psButtonText: 'psButtonText',
+    psProcessingText: 'psProcessingText',
+    psButtonDisabled: false,
+  };
+
+  let container: HTMLElement;
+
+  beforeEach(() => {
+    const view = render(<ProcessingStep {...PROCESSING_STEP_PROPS} />);
+    container = view.container;
+  });
+
+  test('renders container', async () => {
+    await waitFor(() => {
+      const processing = container.querySelector('.droppable-processing-card');
+      expect(processing).toBeInTheDocument();
+    });
+  });
+
+  test('renders ProcessIndicator with default status', () => {
+    expect(screen.getByText(PROCESSING_STEP_PROPS.psProcessingText)).toBeInTheDocument();
+  });
+
+  test('renders ProcessIndicator with success status', async () => {
+    const { container } = render(<ProcessingStep {...PROCESSING_STEP_PROPS} isSuccess />);
+    await waitFor(() => {
+      const processIndicator = container.querySelector('.process-success');
+      expect(processIndicator).toBeInTheDocument();
+    });
+  });
+
+  test('renders ProcessIndicator with error status', async () => {
+    const { container } = render(<ProcessingStep {...PROCESSING_STEP_PROPS} isError />);
+    await waitFor(() => {
+      const processIndicator = container.querySelector('.process-danger');
+      expect(processIndicator).toBeInTheDocument();
+    });
+  });
+
+  test('renders button when psButtonText is set up', () => {
+    expect(screen.getByText(PROCESSING_STEP_PROPS.psButtonText)).toBeInTheDocument();
+  });
+
+  test('calls onClear when button is clicked', () => {
+    fireEvent.click(screen.getByText(PROCESSING_STEP_PROPS.psButtonText));
+    expect(PROCESSING_STEP_PROPS.onClear).toHaveBeenCalledTimes(1);
+  });
+});

package/src/upload/steps/uploadImageStep/uploadImageStep.spec.tsx

@@ -0,0 +1,79 @@
+import { render, screen } from '../../../test-utils';
+
+import UploadImageStep from '.';
+
+beforeAll(() => {
+  Object.defineProperty(window, 'matchMedia', {
+    writable: true,
+    value: jest.fn().mockImplementation((query: string) => ({
+      matches: false,
+      media: query,
+      onchange: null,
+      addListener: jest.fn(),
+      removeListener: jest.fn(),
+      addEventListener: jest.fn(),
+      removeEventListener: jest.fn(),
+      dispatchEvent: jest.fn(),
+    })),
+  });
+});
+
+describe('uploadImageStep', () => {
+  const UPLOADIMAGE_STEP_PROPS = {
+    fileDropped: jest.fn(),
+    isComplete: false,
+    usAccept: 'image/*',
+    usButtonText: 'Upload Image',
+    usDisabled: false,
+    usLabel: 'Upload your image',
+    usHelpImage: 'https://example.com/help-image.png',
+    usPlaceholder: 'Drag and drop an image or click to upload',
+    errorMessage: '',
+    errorIconLabel: '',
+  };
+
+  let container: HTMLElement;
+
+  beforeEach(() => {
+    const view = render(<UploadImageStep {...UPLOADIMAGE_STEP_PROPS} />);
+    container = view.container;
+  });
+
+  test('renders container', () => {
+    const processing = container.querySelector('.droppable-default-card');
+    expect(processing).toBeInTheDocument();
+  });
+
+  test('renders helpImage or Upload icon', () => {
+    const uploadIcons = screen.getAllByAltText('Upload your image');
+    expect(uploadIcons.length).toBeGreaterThan(0);
+    expect(uploadIcons[0]).toBeInTheDocument();
+  });
+
+  test('renders label', () => {
+    expect(screen.getByText(UPLOADIMAGE_STEP_PROPS.usLabel)).toBeInTheDocument();
+  });
+
+  test('renders placeholder', () => {
+    expect(screen.getByText(UPLOADIMAGE_STEP_PROPS.usPlaceholder)).toBeInTheDocument();
+  });
+
+  test('renders buttonText', () => {
+    expect(screen.getByText(UPLOADIMAGE_STEP_PROPS.usButtonText)).toBeInTheDocument();
+  });
+
+  test('should render with `errorIconLabel` and `errorMessage` override', () => {
+    const errorIconLabel = 'Error icon label';
+    const errorMessage = 'Maximum filesize is 2MB.';
+    const { container } = render(
+      <UploadImageStep
+        {...UPLOADIMAGE_STEP_PROPS}
+        errorMessage={errorMessage}
+        errorIconLabel={errorIconLabel}
+      />,
+    );
+
+    expect(screen.getByLabelText(errorIconLabel)).toBeInTheDocument();
+    expect(screen.getByText(errorMessage)).toBeInTheDocument();
+  });
+});

package/build/styles/item/Item.css

@@ -1,60 +0,0 @@
-.np-item {
-  padding: 16px;
-  padding: var(--size-16);
-  border-radius: 24px;
-  border-radius: var(--radius-large);
-  background-color: #ffffff;
-  background-color: var(--color-background-screen);
-  display: flex;
-  gap: 16px;
-  gap: var(--size-16);
-  align-items: center;
-  flex-direction: row;
-  cursor: pointer;
-}
-.np-item:hover {
-  background-color: var(--color-background-screen-hover);
-}
-.np-item:active {
-  background-color: var(--color-background-screen-active);
-}
-.np-item-media {
-  flex: 0 0 auto;
-  align-items: flex-start;
-}
-.np-item-title {
-  color: #37517e;
-  color: var(--color-content-primary);
-}
-.np-item-value {
-  flex: 0 0 auto;
-}
-.np-item-control {
-  flex: 0 0 auto;
-}
-.np-item-spotlight-active {
-  background-color: rgba(134,167,189,0.10196);
-  background-color: var(--color-background-neutral);
-}
-.np-item-spotlight-active:hover {
-  background-color: var(--color-background-neutral-hover);
-}
-.np-item-spotlight-active:active {
-  background-color: var(--color-background-neutral-active);
-}
-.np-item-spotlight-inactive {
-  background-color: rgba(134, 167, 189, 0.025);
-  border: 1px dashed rgba(0,0,0,0.10196);
-  border: 1px dashed var(--color-border-neutral);
-}
-@supports (color: color-mix(in lch, red, blue)) {
-.np-item-spotlight-inactive {
-  background-color: color-mix(in srgb, var(--color-background-neutral) 25%, transparent);
-}
-}
-.np-item-spotlight-inactive:hover {
-  background-color: color-mix(in srgb, var(--color-background-neutral-hover) 25%, transparent);
-}
-.np-item-spotlight-inactive:active {
-  background-color: color-mix(in srgb, var(--color-background-neutral-active) 25%, transparent);
-}

package/build/types/item/Item.d.ts

@@ -1,39 +0,0 @@
-import { ReactNode } from 'react';
-export type ItemTypes = 'none' | 'navigation' | 'radio' | 'checkbox' | 'switch' | 'button' | 'icon-button';
-export type Props = {
-    as?: 'li' | 'div' | 'span';
-    inverted?: boolean;
-    disabled?: boolean;
-    partialInteractivity?: boolean;
-    spotlight?: 'active' | 'inactive';
-    title: ReactNode;
-    subtitle?: ReactNode;
-    additionalInfo?: ReactNode;
-    valueTitle?: ReactNode;
-    valueSubtitle?: ReactNode;
-    media?: ReactNode;
-    control?: ReactNode;
-    prompt?: ReactNode;
-};
-export type ItemContextData = {
-    setControlType: (type: ItemTypes) => void;
-    ids?: {
-        label: string;
-        additionalInfo: string;
-        value: string;
-        control: string;
-        prompt: string;
-    };
-    props: Pick<Props, 'as' | 'disabled' | 'inverted'>;
-};
-export declare const ItemContext: import("react").Context<ItemContextData>;
-export declare const Item: {
-    ({ as: View, title, subtitle, additionalInfo, prompt, inverted, media, spotlight, valueTitle, valueSubtitle, control, disabled, }: Props): import("react").JSX.Element;
-    Image: (props: import("./ItemImage").ItemImageProps) => import("react").JSX.Element;
-    AdditionalInfo: ({ children, action }: import("./ItemAdditionalInfo").ItemAdditionalInfoProps) => import("react").JSX.Element;
-    Checkbox: (props: import("./ItemCheckbox").ItemCheckboxProps) => import("react").JSX.Element;
-    IconButton: (props: import("./ItemIconButton").ItemIconButtonProps) => import("react").JSX.Element;
-    Navigation: ({ onClick }: import("./ItemNavigation").ItemNavigationProps) => import("react").JSX.Element;
-};
-export default Item;
-//# sourceMappingURL=Item.d.ts.map

package/build/types/item/Item.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Item.d.ts","sourceRoot":"","sources":["../../../src/item/Item.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAiB,SAAS,EAA4B,MAAM,OAAO,CAAC;AAU3E,MAAM,MAAM,SAAS,GACjB,MAAM,GACN,YAAY,GACZ,OAAO,GACP,UAAU,GACV,QAAQ,GACR,QAAQ,GACR,aAAa,CAAC;AAElB,MAAM,MAAM,KAAK,GAAG;IAClB,EAAE,CAAC,EAAE,IAAI,GAAG,KAAK,GAAG,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,SAAS,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAC;IAClC,KAAK,EAAE,SAAS,CAAC;IACjB,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,cAAc,CAAC,EAAE,SAAS,CAAC;IAC3B,UAAU,CAAC,EAAE,SAAS,CAAC;IACvB,aAAa,CAAC,EAAE,SAAS,CAAC;IAC1B,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB,MAAM,CAAC,EAAE,SAAS,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,cAAc,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,IAAI,CAAC;IAC1C,GAAG,CAAC,EAAE;QACJ,KAAK,EAAE,MAAM,CAAC;QACd,cAAc,EAAE,MAAM,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,GAAG,UAAU,GAAG,UAAU,CAAC,CAAC;CACpD,CAAC;AAIF,eAAO,MAAM,WAAW,0CAAuC,CAAC;AAEhE,eAAO,MAAM,IAAI;uIAad,KAAK;;;;;;CA8EP,CAAC;AAUF,eAAe,IAAI,CAAC"}

package/build/types/item/ItemAdditionalInfo.d.ts

@@ -1,7 +0,0 @@
-import { PropsWithChildren } from 'react';
-import { LinkProps } from '../link';
-export type ItemAdditionalInfoProps = PropsWithChildren<{
-    action: Pick<LinkProps, 'href' | 'onClick' | 'target'>;
-}>;
-export declare const AdditionalInfo: ({ children, action }: ItemAdditionalInfoProps) => import("react").JSX.Element;
-//# sourceMappingURL=ItemAdditionalInfo.d.ts.map

package/build/types/item/ItemAdditionalInfo.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ItemAdditionalInfo.d.ts","sourceRoot":"","sources":["../../../src/item/ItemAdditionalInfo.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAoC,MAAM,OAAO,CAAC;AAG5E,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEpC,MAAM,MAAM,uBAAuB,GAAG,iBAAiB,CAAC;IACtD,MAAM,EAAE,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,QAAQ,CAAC,CAAC;CACxD,CAAC,CAAC;AAEH,eAAO,MAAM,cAAc,yBAAmC,uBAAuB,gCAIpF,CAAC"}

package/build/types/item/ItemCheckbox.d.ts

@@ -1,4 +0,0 @@
-import { CheckboxButtonProps } from '../checkboxButton/CheckboxButton';
-export type ItemCheckboxProps = Pick<CheckboxButtonProps, 'checked' | 'indeterminate' | 'onChange'>;
-export declare const Checkbox: (props: ItemCheckboxProps) => import("react").JSX.Element;
-//# sourceMappingURL=ItemCheckbox.d.ts.map

package/build/types/item/ItemCheckbox.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ItemCheckbox.d.ts","sourceRoot":"","sources":["../../../src/item/ItemCheckbox.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAGvE,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,mBAAmB,EAAE,SAAS,GAAG,eAAe,GAAG,UAAU,CAAC,CAAC;AAEpG,eAAO,MAAM,QAAQ,UAAoB,iBAAiB,gCAQzD,CAAC"}

package/build/types/item/ItemIconButton.d.ts

@@ -1,4 +0,0 @@
-import { IconButtonProps } from '../iconButton';
-export type ItemIconButtonProps = Pick<IconButtonProps, 'onClick' | 'href' | 'target'>;
-export declare const IconButton: (props: ItemIconButtonProps) => import("react").JSX.Element;
-//# sourceMappingURL=ItemIconButton.d.ts.map

package/build/types/item/ItemIconButton.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ItemIconButton.d.ts","sourceRoot":"","sources":["../../../src/item/ItemIconButton.tsx"],"names":[],"mappings":"AACA,OAAO,EAA6B,eAAe,EAAE,MAAM,eAAe,CAAC;AAG3E,MAAM,MAAM,mBAAmB,GAAG,IAAI,CAAC,eAAe,EAAE,SAAS,GAAG,MAAM,GAAG,QAAQ,CAAC,CAAC;AAEvF,eAAO,MAAM,UAAU,UAAoB,mBAAmB,gCAQ7D,CAAC"}

package/build/types/item/ItemImage.d.ts

@@ -1,4 +0,0 @@
-import { ImageProps } from '../image/Image';
-export type ItemImageProps = Pick<ImageProps, 'src' | 'alt'>;
-export declare const Image: (props: ItemImageProps) => import("react").JSX.Element;
-//# sourceMappingURL=ItemImage.d.ts.map

package/build/types/item/ItemImage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ItemImage.d.ts","sourceRoot":"","sources":["../../../src/item/ItemImage.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAkB,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAE5D,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,UAAU,EAAE,KAAK,GAAG,KAAK,CAAC,CAAC;AAE7D,eAAO,MAAM,KAAK,UAAoB,cAAc,gCAInD,CAAC"}

package/build/types/item/ItemNavigation.d.ts

@@ -1,4 +0,0 @@
-import { ButtonProps } from '../button/Button.types';
-export type ItemNavigationProps = Pick<ButtonProps, 'onClick' | 'href'>;
-export declare const Navigation: ({ onClick }: ItemNavigationProps) => import("react").JSX.Element;
-//# sourceMappingURL=ItemNavigation.d.ts.map

package/build/types/item/ItemNavigation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ItemNavigation.d.ts","sourceRoot":"","sources":["../../../src/item/ItemNavigation.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAIrD,MAAM,MAAM,mBAAmB,GAAG,IAAI,CAAC,WAAW,EAAE,SAAS,GAAG,MAAM,CAAC,CAAC;AAExE,eAAO,MAAM,UAAU,gBAAoC,mBAAmB,gCAQ7E,CAAC"}

package/build/types/item/index.d.ts

@@ -1,5 +0,0 @@
-export type { Props as ItemProps } from './Item';
-export type { ItemAdditionalInfoProps } from './ItemAdditionalInfo';
-export type { ItemCheckboxProps } from './ItemCheckbox';
-export { default } from './Item';
-//# sourceMappingURL=index.d.ts.map

package/build/types/item/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/item/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,KAAK,IAAI,SAAS,EAAE,MAAM,QAAQ,CAAC;AACjD,YAAY,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AACpE,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC"}