jamespot-react-components 1.0.0

package/build/src/components/JRCList/JRCList.d.ts

@@ -0,0 +1,25 @@
+import { SortingRule, Column } from 'react-table';
+/**
+ * Props type for JRCList
+ */
+export declare type JRCListProps<T extends Record<string, unknown>> = {
+    columns: Array<Column<T>>;
+    data: Array<T>;
+    eventHandlers?: {
+        onDrag?: (src: object, target: object, position: string, records: Array<T>) => void;
+        onSort?: (sortBy: Array<SortingRule<T>>) => void;
+        onPage?: (page: number) => void;
+    };
+    config: {
+        manualSortBy: boolean;
+        draggable: boolean;
+        pagination?: {
+            type?: string;
+            end?: boolean;
+            page: number;
+            perPage: number;
+            nbResults: number;
+        };
+    };
+};
+export declare const JRCList: <T extends Record<string, unknown>>(props: JRCListProps<T>) => JSX.Element;

package/build/src/components/JRCList/JRCList.stories.d.ts

@@ -0,0 +1,11 @@
+import { JRCListProps } from './JRCList';
+import { Meta, Story } from '@storybook/react';
+declare const _default: Meta<import("@storybook/react").Args>;
+export default _default;
+declare type MyData = {
+    col1: number;
+    col2: number;
+    col3: number;
+    col4: number;
+};
+export declare const Primary: Story<JRCListProps<MyData>>;

package/build/src/components/JRCList/JRCList.styles.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="react" />
+export declare const Table: import("styled-components").StyledComponent<"table", any, {}, never>;
+export declare const Thead: import("styled-components").StyledComponent<"thead", any, {}, never>;
+export declare const TBody: import("styled-components").StyledComponent<"tbody", any, {}, never>;
+export declare const Th: import("styled-components").StyledComponent<"th", any, {
+    width?: string | undefined;
+}, never>;
+export declare const Tr: import("styled-components").StyledComponent<"tr", any, {}, never>;
+export declare const Td: import("styled-components").StyledComponent<"td", any, {}, never>;
+export declare const LoadMore: import("styled-components").StyledComponent<"td", any, {
+    end?: boolean | undefined;
+}, never>;
+export declare const LoadMoreButton: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare type DraggableTBodyProps = {
+    draggable: boolean;
+    children: Array<JSX.Element>;
+};
+export declare type DraggableTrProps = {
+    index: number;
+    moveRow: (dragIndex: number, hoverIndex: number) => void;
+    draggable: boolean;
+    children: Array<JSX.Element>;
+};
+export declare const DraggableTBody: ({ draggable, children }: DraggableTBodyProps) => JSX.Element;
+export declare const DraggableTr: ({ index, moveRow, draggable, children }: DraggableTrProps) => JSX.Element;

package/build/src/components/JRCList/JRCListMockData.stories.d.ts

@@ -0,0 +1,4 @@
+import { Meta, Story } from '@storybook/react';
+declare const _default: Meta<import("@storybook/react").Args>;
+export default _default;
+export declare const WithData: Story<never>;

package/build/src/components/JRCLoader/JRCLoader.d.ts

@@ -0,0 +1,12 @@
+import { Colors } from '../../styles/theme';
+/**
+ * Props type for JRCLoader
+ * @member color string based on theme.tsx colors
+ * @member size size of the loader, default is s, 20px width
+ */
+export interface JRCLoaderProps {
+    color?: Colors;
+    size?: 's' | 'm' | 'l';
+}
+declare const JRCLoader: ({ color, size }: JRCLoaderProps) => JSX.Element;
+export default JRCLoader;

package/build/src/components/JRCLoader/JRCLoader.stories.d.ts

@@ -0,0 +1,5 @@
+import { JRCLoaderProps } from './JRCLoader';
+import { Meta, Story } from '@storybook/react';
+declare const _default: Meta<import("@storybook/react").Args>;
+export default _default;
+export declare const Primary: Story<JRCLoaderProps>;

package/build/src/components/JRCMenu/JRCMenu.d.ts

@@ -0,0 +1,33 @@
+import React from 'react';
+/**
+ * Interface of a single Menu Item  props
+ * @member label string content of the menu item
+ * @member clickHandler function (event?: React.MouseEvent)=> void, callback called when onClick the menu item
+ */
+export interface JRCMenuItemProps {
+    label: string | JSX.Element;
+    clickHandler: (event?: React.MouseEvent) => void;
+}
+/**
+ * Interface to provide Menu props
+ * @member items List of MenuItem props @see JRCMenuItemProps
+ * @member defaultActiveItem optional index [0,items.length-1] of the defaultActive item when mounting
+
+ */
+export interface JRCMenuProps {
+    items: JRCMenuItemProps[];
+    defaultActiveItem?: number;
+}
+export declare const MenuWrapper: import("styled-components").StyledComponent<"div", any, {}, never>;
+interface MenuItemProps {
+    isActive: boolean;
+}
+export declare const MenuItem: import("styled-components").StyledComponent<"div", any, MenuItemProps, never>;
+export declare const MenuItemLabel: import("styled-components").StyledComponent<"span", any, {}, never>;
+/**
+ *
+ * @param {items, defaultActiveItem} Menu props, @see JRCMenuProps interface
+ * @returns JSX.Element
+ */
+declare const JRCMenu: ({ items, defaultActiveItem }: JRCMenuProps) => JSX.Element;
+export default JRCMenu;

package/build/src/components/JRCMenu/JRCMenu.stories.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+declare const _default: {
+    title: string;
+    component: ({ items, defaultActiveItem }: import("./JRCMenu").JRCMenuProps) => JSX.Element;
+};
+export default _default;
+export declare const jrcmenu: () => JSX.Element;

package/build/src/components/JRCModal/JRCModal.d.ts

@@ -0,0 +1,38 @@
+import React, { ComponentPropsWithoutRef, ReactNode } from 'react';
+/**
+ * Interface to provide Modal Buttons
+ * @member color button color "primary" | "red" | "green" | "grey"
+ * @member isClosed optional boolean (default false). If true, when click on the button, the modal is closes
+ * @member clickHandler optional, callback when the button is click
+ * @member children default ReactNode children in the Modal content
+ */
+export interface JRCModalButtonType extends ComponentPropsWithoutRef<'button'> {
+    children: ReactNode;
+    color?: 'primary' | 'valid' | 'danger';
+    variant?: 'contained' | 'outlined';
+    isClosed?: boolean;
+    clickHandler?: (event?: React.MouseEvent) => void;
+}
+/**
+ * Interface for JRCModal props
+ * @member open boolean that open or close the Modal
+ * @member closeHandler callback called when the Modal is closed
+ * @member buttons array of JRCModalButton possibly added to the Modal
+ * @member title optional string or JSX.Element (header content) if hasHeader= true
+ * @member showIconClose boolean to show/hide the close (x) button of the Modal
+ * @member enableClickAwayCloseModal boolean to enable the close of the Modal by Click Outside of Modal
+ * @member children default ReactNode children in the Modal content
+ * @member alignContent content's align, default:flex-start
+ */
+export interface JRCModalProps {
+    open: boolean;
+    closeHandler: () => void;
+    buttons?: JRCModalButtonType[];
+    children?: ReactNode;
+    title?: React.ReactNode;
+    showIconClose?: boolean;
+    enableClickAwayCloseModal?: boolean;
+    alignContent?: 'flex-start' | 'center' | 'flex-end';
+}
+declare const JRCModal: ({ open, closeHandler, buttons, children, title, showIconClose, enableClickAwayCloseModal, alignContent, }: JRCModalProps) => JSX.Element | null;
+export default JRCModal;

package/build/src/components/JRCModal/JRCModal.stories.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { JRCModalProps } from './JRCModal';
+import { Meta, Story } from '@storybook/react';
+declare const _default: Meta<import("@storybook/react").Args>;
+export default _default;
+export declare const SkeletonModal: Story<JRCModalProps>;
+export declare const ShowAndHideModal: (args: JRCModalProps) => JSX.Element;
+export declare const ShowAndHideAndClickOutsideModal: (args: JRCModalProps) => JSX.Element;

package/build/src/components/JRCModal/JRCModal.styles.d.ts

@@ -0,0 +1,15 @@
+export declare const JRCModalBox: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const JRCModalContainer: import("styled-components").StyledComponent<"div", any, {}, never>;
+/**
+ * Type for align content
+ * @member align left: 'flex-start' | align center: 'center' | align right: 'flex-end'
+ */
+declare type AlignProps = {
+    align?: 'flex-start' | 'center' | 'flex-end';
+};
+export declare const JRCModalContent: import("styled-components").StyledComponent<"div", any, AlignProps, never>;
+export declare const JRCModalContentScrollbox: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const JRCModalHeader: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const JRCModalFooter: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const JRCModalClose: import("styled-components").StyledComponent<"div", any, {}, never>;
+export {};

package/build/src/components/JRCModalImg/JRCModalImg.d.ts

@@ -0,0 +1,40 @@
+import React, { ComponentPropsWithoutRef, ReactNode } from 'react';
+/**
+ * Interface to provide Modal Buttons
+ * @member color button color "primary" | "red" | "green" | "grey"
+ * @member isClosed optional boolean (default false). If true, when click on the button, the modal is closes
+ * @member clickHandler optional, callback when the button is click
+ * @member children default ReactNode children in the Modal content
+ * @member variant optional style button "contained" | "outlined"
+ */
+export interface JRCModalImgButtonType extends ComponentPropsWithoutRef<'button'> {
+    children: ReactNode;
+    color?: 'primary' | 'valid' | 'danger';
+    variant?: 'contained' | 'outlined';
+    isClosed?: boolean;
+    clickHandler?: (event?: React.MouseEvent) => void;
+}
+/**
+ * Interface for JRCModal props
+ * @member open boolean that open or close the Modal
+ * @member closeHandler callback called when the Modal is closed
+ * @member buttons array of JRCModalButton possibly added to the Modal
+ * @member title optional string (header content) if hasHeader= true
+ * @member showIconClose boolean to show/hide the close (x) button of the Modal
+ * @member children default ReactNode children in the Modal content
+ * @member alignContent content's align, default:flex-start
+ * @member img path image type string
+ * @member size modal max height
+ */
+export interface JRCModalImgProps {
+    open: boolean;
+    closeHandler: () => void;
+    buttons?: JRCModalImgButtonType[];
+    children?: ReactNode;
+    title?: string;
+    showIconClose?: boolean;
+    img: string;
+    alignContent?: 'flex-start' | 'center' | 'flex-end';
+}
+declare const JRCModalImg: ({ open, closeHandler, buttons, children, title, showIconClose, img, alignContent, }: JRCModalImgProps) => JSX.Element | null;
+export default JRCModalImg;

package/build/src/components/JRCModalImg/JRCModalImg.stories.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { JRCModalImgProps } from './JRCModalImg';
+import { Meta, Story } from '@storybook/react';
+declare const _default: Meta<import("@storybook/react").Args>;
+export default _default;
+export declare const SkeletonModal: Story<JRCModalImgProps>;
+export declare const ShowAndHideModal: (args: JRCModalImgProps) => JSX.Element;

package/build/src/components/JRCModalImg/JRCModalImg.styles.d.ts

@@ -0,0 +1,15 @@
+export declare const JRCModalBox: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const JRCModalContainer: import("styled-components").StyledComponent<"div", any, {}, never>;
+/**
+ * Type for align content
+ * @member align left: 'flex-start' | align center: 'center' | align right: 'flex-end'
+ */
+declare type AlignProps = {
+    align?: 'flex-start' | 'center' | 'flex-end';
+};
+export declare const JRCModalContent: import("styled-components").StyledComponent<"div", any, AlignProps, never>;
+export declare const JRCModalFooter: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const JRCModalClose: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const ImgContainer: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const ContentContainer: import("styled-components").StyledComponent<"div", any, {}, never>;
+export {};

package/build/src/components/JRCPagination/JRCPagination.d.ts

@@ -0,0 +1,20 @@
+import { DataCy } from '../../types/dataAttributes';
+export declare type PaginationBulletProps = DataCy & {
+    number: number;
+    isActive: boolean;
+    clickHandler: (page: number) => void;
+};
+/**
+ * Props type for JRCPagination
+ * @member activePage number :  active page Number
+ * @member nbrOfPage number : total nb of pages
+ * @member clickHandler (page: number) => void; callback when click on a page number
+ */
+export declare type JRCPaginationProps = DataCy & {
+    activePage: number;
+    nbrOfPage: number;
+    clickHandler: (page: number) => void;
+};
+export declare const PaginationBullet: ({ number, isActive, dataCy, clickHandler }: PaginationBulletProps) => JSX.Element;
+declare const JRCPagination: ({ activePage, nbrOfPage, clickHandler, dataCy }: JRCPaginationProps) => JSX.Element;
+export default JRCPagination;

package/build/src/components/JRCPagination/JRCPagination.stories.d.ts

@@ -0,0 +1,8 @@
+import { JRCPaginationProps } from './JRCPagination';
+import { Meta, Story } from '@storybook/react';
+declare const _default: Meta<import("@storybook/react").Args>;
+export default _default;
+export declare const PaginationFirst: Story<JRCPaginationProps>;
+export declare const PaginationFirstBis: Story<JRCPaginationProps>;
+export declare const PaginationMiddle: Story<JRCPaginationProps>;
+export declare const PaginationFinal: Story<JRCPaginationProps>;

package/build/src/components/JRCPagination/JRCPagination.test.d.ts

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

package/build/src/components/JRCTabs/JRCTabs.d.ts

@@ -0,0 +1,44 @@
+import React from 'react';
+export interface ItemProps {
+    isActive: boolean;
+}
+export declare const VerticalWrapper: import("styled-components").StyledComponent<"nav", any, {}, never>;
+export declare const VerticalItem: import("styled-components").StyledComponent<"button", any, ItemProps, never>;
+/**
+ * Interface of a single Menu Item  props
+ * @member label label of the tag
+ * @member content content of the tag
+ */
+export interface ItemEntriesProps {
+    key: string;
+    label: React.ReactNode;
+}
+/**
+ * Interface to provide JRCTabs props
+ * @member entries List of Item props @see ItemEntriesProps
+ * @member activeItem optional index [0,items.length-1] of the defaultActive item when mounting
+ * @member direction direction of tab to horizontal or vertical
+ * @member callback tab selection handler
+ */
+export interface JRCTabsProps {
+    entries: ItemEntriesProps[];
+    activeItem?: string;
+    direction: 'horizontal' | 'vertical';
+    callback: (key: string) => void;
+}
+/**
+ *
+ * @param {entries, activeItem, direction} props, @see JRCTabsProps interface
+ * @returns JSX.Element
+ */
+export declare const JRCTabs: ({ entries, activeItem, direction, callback }: JRCTabsProps) => JSX.Element;
+/**
+ * Interface to provide JRCTabPanel props
+ * @member active whether the tab is active
+ * @member children children
+ */
+export interface JRCTabPanelProps {
+    active: boolean;
+    children: React.ReactNode;
+}
+export declare const JRCTabPanel: ({ children, active }: JRCTabPanelProps) => JSX.Element;

package/build/src/components/JRCTabs/JRCTabs.stories.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+declare const _default: {
+    title: string;
+    component: ({ entries, activeItem, direction, callback }: import("./JRCTabs").JRCTabsProps) => JSX.Element;
+};
+export default _default;
+export declare const TabHorizontal: () => JSX.Element;
+export declare const TabVertical: () => JSX.Element;
+export declare const EmbeddedTab: () => JSX.Element;

package/build/src/components/JRCTag/JRCTag.d.ts

@@ -0,0 +1,29 @@
+import * as React from 'react';
+import { UriOrTypeId } from 'components/Form/Common/types';
+/**
+ * /!\ This component is overkilled. Use with care since it may be simplified later on!
+ *
+ * @see UriOrTypeId
+ * @member collapsed - whether the tag is collapsed or not
+ * @member label - label aside from the avatar
+ * @member value - value passed as the onClick argument
+ * @member onClick - onClick method
+ * @member onMouseDown - callback on mouse down
+ * @member variant - whether the avatar is circular or square
+ * @member focusable - whether the element is focusable. Independant of onClick property
+ * @member isFocused - whether the element is focused. Property used with variant for styling the component
+ * @member tooltipDescription - if present, show a tooltip with the description
+ */
+export declare type JRCTagProps<T> = UriOrTypeId & {
+    collapsed?: boolean;
+    label?: string;
+    value?: T;
+    onClick?: (e: React.MouseEvent, value: T) => void;
+    onMouseDown?: React.MouseEventHandler<HTMLDivElement>;
+    variant?: 'circle' | 'square';
+    focusable?: boolean;
+    isFocused?: boolean;
+    tooltipDescription?: string;
+    alt?: string;
+};
+export declare function JRCTag<T>(props: JRCTagProps<T>): JSX.Element;

package/build/src/components/JRCTag/JRCTag.stories.d.ts

@@ -0,0 +1,5 @@
+import { JRCTagProps } from './JRCTag';
+import { Meta, Story } from '@storybook/react';
+declare const _default: Meta<import("@storybook/react").Args>;
+export default _default;
+export declare const Primary: Story<JRCTagProps<string>>;

package/build/src/components/JRCThemeProvider/JRCThemeProvider.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import './theme-reset.css';
+import './fontawesome-icons.css';
+import './fontspot-icons.css';
+import './font.css';
+import './gabarit.css';
+import './scrollbar.css';
+import './animation.css';
+/**
+ * Props Type for JRCThemeProviderProps
+ * @member children : enclosed React component
+ */
+export interface JRCThemeProviderProps {
+    children: React.ReactNode;
+}
+declare const JRCThemeProvider: (props: JRCThemeProviderProps) => JSX.Element;
+export default JRCThemeProvider;

package/build/src/components/JRCTooltip/JRCTooltip.d.ts

@@ -0,0 +1,26 @@
+import { JRCButtonProps } from 'components/JRCButton/JRCButton';
+import * as React from 'react';
+/**
+ * Props type for JRCTooltip
+ * @member children : enclosed React component (on which the tootip is set)
+ * @member title string, optional: Tooltip title
+ * @member description: string : Content of the tooltip
+ * @member closeButton: boolean, optional: Add a close button to the tooltip
+ * @member button: @see JRCButtonProps, optional: Add a button to the tooltip
+ * @member position: optional, "top" | "bottom" | "left" | "right": Chose the placement of the tooltip
+ */
+export interface JRCTooltipProps {
+    children: React.ReactNode;
+    /** Tooltip title */
+    title?: string;
+    /** Content of the tooltip */
+    description: string;
+    /** Add a close button to the tooltip */
+    closeButton?: boolean;
+    /** Add a button to the tooltip */
+    button?: JRCButtonProps;
+    /** Chose the placement of the tooltip */
+    position?: 'top' | 'bottom' | 'left' | 'right';
+}
+export declare const JRCTooltip: (props: JRCTooltipProps) => JSX.Element;
+export default JRCTooltip;

package/build/src/components/JRCTooltip/JRCTooltip.stories.d.ts

@@ -0,0 +1,9 @@
+import { JRCTooltipProps } from './JRCTooltip';
+import { Meta, Story } from '@storybook/react';
+declare const _default: Meta<import("@storybook/react").Args>;
+export default _default;
+export declare const Default: Story<JRCTooltipProps>;
+export declare const SmallTooltip: Story<JRCTooltipProps>;
+export declare const LargeTooltipWithTitle: Story<JRCTooltipProps>;
+export declare const LargeTooltipWithoutTitle: Story<JRCTooltipProps>;
+export declare const LargeTooltipWithButton: Story<JRCTooltipProps>;

package/build/src/components/JRCTypo/JRCTypo.d.ts

@@ -0,0 +1,48 @@
+import * as React from 'react';
+/**
+ * @deprecated use JRCTypography instead
+ * Props Type for JRCH1
+ * @see HTML.H1 props
+ */
+export declare type JRCH1Props = React.ComponentPropsWithoutRef<'h1'>;
+declare const JRCH1: import("styled-components").StyledComponent<"h1", any, Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "key" | keyof React.HTMLAttributes<HTMLHeadingElement>>, never>;
+/**
+ * @deprecated use JRCTypography instead
+ * Props Type for JRCH2
+ * @see HTML.H2 props
+ */
+export declare type JRCH2Props = React.ComponentPropsWithoutRef<'h2'>;
+declare const JRCH2: import("styled-components").StyledComponent<"h2", any, Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "key" | keyof React.HTMLAttributes<HTMLHeadingElement>>, never>;
+/**
+ * @deprecated use JRCTypography instead
+ * Props Type for JRCH3
+ * @see HTML.H3 props
+ */
+export declare type JRCH3Props = React.ComponentPropsWithoutRef<'h3'>;
+declare const JRCH3: import("styled-components").StyledComponent<"h3", any, Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "key" | keyof React.HTMLAttributes<HTMLHeadingElement>>, never>;
+/**
+ * @deprecated use JRCTypography instead
+ * Props Type for JRCH4
+ * @see HTML.H4 props
+ */
+export declare type JRCH4Props = React.ComponentPropsWithoutRef<'h3'>;
+declare const JRCH4: import("styled-components").StyledComponent<"h4", any, Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "key" | keyof React.HTMLAttributes<HTMLHeadingElement>>, never>;
+/**
+ * @deprecated use JRCTypography instead
+ * Props Type for JRCH5
+ * @see HTML.H5 props
+ */
+export declare type JRCH5Props = React.ComponentPropsWithoutRef<'h5'>;
+declare const JRCH5: import("styled-components").StyledComponent<"h5", any, Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "key" | keyof React.HTMLAttributes<HTMLHeadingElement>>, never>;
+/**
+ * @deprecated use JRCTypography instead
+ * Props Type for JRCText
+ * @member size: optionnal size of the text 's'|'m'|'l'
+ */
+export interface JRCTextProps {
+    /** Size of the text */
+    size?: 's' | 'm' | 'l';
+}
+declare const Text: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<JRCTextProps, any>>;
+declare const JRCText: import("styled-components").StyledComponent<"p", any, JRCTextProps, never>;
+export { JRCH1, JRCH2, JRCH3, JRCH4, JRCH5, Text, JRCText };

package/build/src/components/JRCTypo/JRCTypo.stories.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { JRCH1Props, JRCH2Props, JRCH3Props, JRCH4Props, JRCH5Props, JRCTextProps } from './JRCTypo';
+declare const _default: {
+    title: string;
+};
+export default _default;
+export declare const H1: (args: JRCH1Props) => JSX.Element;
+export declare const H2: (args: JRCH2Props) => JSX.Element;
+export declare const H3: (args: JRCH3Props) => JSX.Element;
+export declare const H4: (args: JRCH4Props) => JSX.Element;
+export declare const H5: (args: JRCH5Props) => JSX.Element;
+export declare const P: (args: JRCTextProps) => JSX.Element;

package/build/src/components/JRCTypography/JRCTypography.d.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import { Colors, FontWeight } from '../../styles/theme';
+export declare type TSizes = 's' | 'm' | 'l' | 'xl' | 'xxl' | 'xxxl';
+export declare type TVariants = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'p' | 'span';
+export declare type TWeight = keyof FontWeight;
+/**
+ * Props type for JRCTypography
+ * @member children ReactNode content of the button
+ * @member className optional Additional className for override the component
+ * @member weight optional You can custom the font-weight with the weight property
+ * @member size You can change the font-size with the size property
+ * @member variant You can change the semantic element with the variant property
+ */
+export interface JRCTypographyProps {
+    /** Additional className for override the component: */
+    className?: string;
+    /** You can custom the font-weight with the weight property */
+    weight?: TWeight;
+    /** You can change the font-size with the size property */
+    size?: TSizes;
+    /** Text color */
+    color?: Colors;
+    /**ReactNode | text content of the button */
+    children: string | React.ReactNode;
+    /** You can change the semantic element with the variant property */
+    variant?: TVariants;
+}

package/build/src/components/JRCTypography/JRCTypography.d.ts

@@ -0,0 +1,2 @@
+import { JRCTypographyProps } from './JRCTypography.d';
+export declare const JRCTypography: ({ variant, ...props }: JRCTypographyProps) => JSX.Element;

package/build/src/components/JRCTypography/JRCTypography.stories.d.ts

@@ -0,0 +1,5 @@
+import { Meta, Story } from '@storybook/react';
+import { JRCTypographyProps } from './JRCTypography.d';
+declare const _default: Meta<import("@storybook/react").Args>;
+export default _default;
+export declare const Typography: Story<JRCTypographyProps>;

package/build/src/components/JRCTypography/JRCTypography.styles.d.ts

@@ -0,0 +1,10 @@
+import { JRCTypographyProps } from './JRCTypography.d';
+export declare const SIZES: Readonly<{
+    s: string;
+    m: string;
+    l: string;
+    xl: string;
+    xxl: string;
+    xxxl: string;
+}>;
+export declare const Typography: import("styled-components").StyledComponent<"p", any, Pick<JRCTypographyProps, "color" | "size" | "weight">, never>;

package/build/src/components/JRCTypography/JRCTypography.test.d.ts

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

package/build/src/hooks/UseDebounce.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This hook provides a way to retrieve only the last value (after the delay has been passed without any change)
+ * To put it in context, if the user is typing within a search box, the debounced value will be returned when
+ * they've stopped typing for more than 200ms (delay).
+ * @param value value to debounce
+ * @param delay delay
+ */
+export declare function useDebounce(value: string, delay?: number): string;

package/build/src/hooks/UseDidMountEffect.d.ts

@@ -0,0 +1,3 @@
+import { DependencyList } from 'react';
+declare const useDidMountEffect: (func: Function, deps: DependencyList) => void;
+export default useDidMountEffect;