cortex-react-ui 0.2.16 → 0.2.17

package/lib/esm/utils/forwardRef.d.ts

@@ -0,0 +1,35 @@
+import * as React from 'react';
+/**
+ * Utility type pour créer des props avec ref pour la compatibilité React 18/19
+ * En React 19, ref est passé directement dans les props
+ * En React 18, ref est passé séparément via forwardRef
+ */
+export type ForwardRefProps<T, P = object> = P & {
+    ref?: React.Ref<T>;
+};
+/**
+ * Type pour la fonction de rendu compatible React 18/19
+ */
+export type ForwardRefRenderFunction<T, P> = (props: P, ref: React.ForwardedRef<T>) => React.ReactElement | null;
+/**
+ * Composant wrapper compatible React 18 et React 19
+ *
+ * Utilise la signature standard de React.forwardRef qui est compatible
+ * avec les deux versions de React.
+ *
+ * @example
+ * ```tsx
+ * interface MyComponentProps {
+ *   className?: string;
+ *   children?: React.ReactNode;
+ * }
+ *
+ * const MyComponent = forwardRef<HTMLDivElement, MyComponentProps>(
+ *   (props, ref) => (
+ *     <div ref={ref} className={props.className}>{props.children}</div>
+ *   )
+ * );
+ * ```
+ */
+export declare function forwardRef<T, P>(render: ForwardRefRenderFunction<T, P>): React.ForwardRefExoticComponent<React.PropsWithoutRef<P> & React.RefAttributes<T>>;
+export default forwardRef;

package/lib/esm/utils/setRef.d.ts

@@ -1,2 +1,9 @@
-/// <reference types="react" />
-export default function setRef<T>(ref: React.MutableRefObject<T | null> | ((instance: T | null) => void) | null | undefined, value: T | null): void;
+import * as React from 'react';
+/**
+ * Helper pour assigner une valeur à une ref React
+ * Compatible avec React 18 et React 19
+ *
+ * @param ref - La ref React (callback ref, MutableRefObject, ou RefObject)
+ * @param value - La valeur à assigner
+ */
+export default function setRef<T>(ref: React.Ref<T> | null | undefined, value: T | null): void;

package/lib/esm/utils/useForkRef.d.ts

@@ -1,2 +1,10 @@
 import * as React from 'react';
-export default function useForkRef<Instance>(refA: React.Ref<Instance> | null | undefined, refB: React.Ref<Instance> | null | undefined): React.Ref<Instance> | null;
+/**
+ * Hook pour combiner plusieurs refs en une seule
+ * Compatible avec React 18 et React 19
+ *
+ * @param refA - Première ref
+ * @param refB - Seconde ref
+ * @returns Une ref qui met à jour les deux refs
+ */
+export default function useForkRef<Instance>(refA: React.Ref<Instance> | null | undefined, refB: React.Ref<Instance> | null | undefined): React.RefCallback<Instance> | null;

package/lib/index.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="react" />
-import React$1, { CSSProperties } from 'react';
+import * as React$1 from 'react';
+import React__default, { CSSProperties } from 'react';
 import { IDetectedBarcode, IScannerProps } from '@yudiel/react-qr-scanner';
 import { WebcamProps } from 'react-webcam';
 import { MapContainerProps } from 'react-leaflet';
@@ -21,7 +22,7 @@ declare const PopperPlacement: {
     readonly RightCenter: "right-center";
 };
 type Props$5 = {
-    anchorEl?: string | HTMLElement | React$1.RefObject<HTMLElement>;
+    anchorEl?: string | HTMLElement | React__default.RefObject<HTMLElement>;
     anchorPosition?: {
         top: number;
         left: number;
@@ -29,30 +30,30 @@ type Props$5 = {
     placement?: ObjectValues<typeof PopperPlacement>;
     open?: boolean;
     role?: string;
-    children?: React$1.ReactNode;
+    children?: React__default.ReactNode;
     className?: string;
     overflow?: boolean;
-    onMouseEnter?: React$1.MouseEventHandler<HTMLDivElement>;
-    onMouseLeave?: React$1.MouseEventHandler<HTMLDivElement>;
-    onMouseMove?: React$1.MouseEventHandler<HTMLDivElement>;
-    onMouseOut?: React$1.MouseEventHandler<HTMLDivElement>;
-    onMouseOver?: React$1.MouseEventHandler<HTMLDivElement>;
-    onTouchStart?: React$1.TouchEventHandler<HTMLDivElement>;
-    onTouchEnd?: React$1.TouchEventHandler<HTMLDivElement>;
+    onMouseEnter?: React__default.MouseEventHandler<HTMLDivElement>;
+    onMouseLeave?: React__default.MouseEventHandler<HTMLDivElement>;
+    onMouseMove?: React__default.MouseEventHandler<HTMLDivElement>;
+    onMouseOut?: React__default.MouseEventHandler<HTMLDivElement>;
+    onMouseOver?: React__default.MouseEventHandler<HTMLDivElement>;
+    onTouchStart?: React__default.TouchEventHandler<HTMLDivElement>;
+    onTouchEnd?: React__default.TouchEventHandler<HTMLDivElement>;
 };
-declare const Popper: React$1.ForwardRefExoticComponent<Props$5 & React$1.RefAttributes<HTMLElement>>;
+declare const Popper: React__default.ForwardRefExoticComponent<Props$5 & React__default.RefAttributes<HTMLElement>>;
 
 type Props$4 = {
-    children?: React$1.ReactNode;
+    children?: React__default.ReactNode;
     container?: HTMLElement | (() => HTMLElement);
 };
-declare const DomContainer: React$1.ForwardRefExoticComponent<Props$4 & React$1.RefAttributes<HTMLElement>>;
+declare const DomContainer: React__default.ForwardRefExoticComponent<Props$4 & React__default.RefAttributes<HTMLElement>>;
 
 interface SpinnerProps {
     className?: string;
     variant?: 'indeterminate' | 'determinate';
 }
-declare const Spinner: React$1.FC<SpinnerProps>;
+declare const Spinner: React__default.FC<SpinnerProps>;
 
 interface BarLoaderProps {
     title?: string;
@@ -60,24 +61,24 @@ interface BarLoaderProps {
     className?: string;
     isComplete: boolean;
 }
-declare const BarLoader: React$1.FC<BarLoaderProps>;
+declare const BarLoader: React__default.FC<BarLoaderProps>;
 
 interface SelectedProps {
     title?: string;
     data: any[];
     onClick: (elt: any) => void;
 }
-declare const Selected: React$1.FC<SelectedProps>;
+declare const Selected: React__default.FC<SelectedProps>;
 
 interface ButtonProps {
     variant?: 'text' | 'contained' | 'outlined';
     color?: 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'light' | 'dark';
     className?: string;
     disable?: boolean;
-    children?: React$1.ReactNode;
-    onClick?: (event: React$1.MouseEvent<HTMLButtonElement>) => void;
+    children?: React__default.ReactNode;
+    onClick?: (event: React__default.MouseEvent<HTMLButtonElement>) => void;
 }
-declare const Button: React$1.FC<ButtonProps>;
+declare const Button: React__default.FC<ButtonProps>;
 
 type TScanConfirmDialogLabels = {
     title?: string;
@@ -125,21 +126,21 @@ interface ToggleButtonProps {
     value?: string;
     className?: string;
     size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
-    children?: React$1.ReactNode;
+    children?: React__default.ReactNode;
     onChange?: (value: string | undefined) => void;
 }
-declare const ToggleButton: React$1.FC<ToggleButtonProps>;
+declare const ToggleButton: React__default.FC<ToggleButtonProps>;
 
 interface TooltipProps$1 {
-    children?: React$1.ReactElement<any>;
-    anchorEl?: string | HTMLElement | React$1.RefObject<HTMLElement>;
-    title: React$1.ReactNode;
+    children?: React__default.ReactElement;
+    anchorEl?: string | HTMLElement | React__default.RefObject<HTMLElement>;
+    title: React__default.ReactNode;
     enterDelay?: number;
     leaveDelay?: number;
     className?: string;
     disabled?: boolean;
 }
-declare const Tooltip: React$1.FC<TooltipProps$1>;
+declare const Tooltip: React__default.FC<TooltipProps$1>;
 
 declare namespace Cortex {
     type Tag = {
@@ -164,7 +165,7 @@ interface TooltipProps {
     onTextChange?: (text: string) => void;
     onChange?: (tags: Cortex.Tag[]) => void;
 }
-declare const TagInput: React$1.FC<TooltipProps>;
+declare const TagInput: React__default.FC<TooltipProps>;
 
 declare class Point {
     id: number;
@@ -235,7 +236,7 @@ type MapsProps = {
     onChange?: (locations: Location[]) => void;
 };
 
-declare const Map: React$1.FC<AppProps>;
+declare const Map: React__default.FC<AppProps>;
 type AppProps = MapsProps & {
     onClose?: (() => void);
     onSave?: ((locations: Location[]) => void);
@@ -247,76 +248,76 @@ type AppProps = MapsProps & {
 };
 
 interface MenuProps {
-    containerRef: React$1.RefObject<HTMLElement>;
+    containerRef: React__default.RefObject<HTMLElement>;
     className?: string;
-    children?: React$1.ReactNode;
+    children?: React__default.ReactNode;
     onClose?: () => void;
-    onClick?: (event: React$1.MouseEvent<HTMLUListElement> | undefined) => void;
+    onClick?: (event: React__default.MouseEvent<HTMLUListElement> | undefined) => void;
 }
-declare const Menu: React$1.FC<MenuProps>;
+declare const Menu: React__default.FC<MenuProps>;
 
 interface ContextMenuProps {
     className?: string;
-    children?: React$1.ReactNode;
+    children?: React__default.ReactNode;
     open?: boolean;
     placement?: ObjectValues<typeof PopperPlacement>;
-    container?: string | HTMLElement | React$1.RefObject<HTMLElement>;
+    container?: string | HTMLElement | React__default.RefObject<HTMLElement>;
     onOpen?: () => void;
     onClose?: () => void;
 }
-declare const ContextMenu: React$1.FC<ContextMenuProps>;
+declare const ContextMenu: React__default.FC<ContextMenuProps>;
 
 interface DividerProps {
     className?: string;
 }
-declare const Divider: React$1.FC<DividerProps>;
+declare const Divider: React__default.FC<DividerProps>;
 
 interface MenuItemProps {
     className?: string;
     style?: CSSProperties | undefined;
-    children?: React$1.ReactNode;
+    children?: React__default.ReactNode;
     label?: string;
-    icon?: React$1.ReactNode;
+    icon?: React__default.ReactNode;
     active?: boolean;
     disable?: boolean;
-    itemTemplate?: React$1.ReactNode;
-    onClick?: (event: React$1.MouseEvent<HTMLButtonElement> | undefined) => void;
+    itemTemplate?: React__default.ReactNode;
+    onClick?: (event: React__default.MouseEvent<HTMLButtonElement> | undefined) => void;
 }
-declare const MenuItem: React$1.FC<MenuItemProps>;
+declare const MenuItem: React__default.FC<MenuItemProps>;
 
 interface PopupMenuProps {
     className?: string;
-    children?: React$1.ReactNode;
+    children?: React__default.ReactNode;
     open?: boolean;
     placement?: ObjectValues<typeof PopperPlacement>;
     anchorPosition?: {
         top: number;
         left: number;
     };
-    anchorEl?: string | HTMLElement | React$1.RefObject<HTMLElement>;
+    anchorEl?: string | HTMLElement | React__default.RefObject<HTMLElement>;
     onClose?: () => void;
 }
-declare const PopupMenu: React$1.FC<PopupMenuProps>;
+declare const PopupMenu: React__default.FC<PopupMenuProps>;
 
 interface MenuGroupProps {
     title?: string;
     className?: string;
-    children?: React$1.ReactNode;
+    children?: React__default.ReactNode;
 }
-declare const MenuGroup: React$1.FC<MenuGroupProps>;
+declare const MenuGroup: React__default.FC<MenuGroupProps>;
 
 interface AuthDownloadLinkProps {
     url: string;
     queryParams?: {
-        [key: string]: any;
+        [key: string]: string | number | boolean;
     };
     token: string;
     label?: string;
-    onStart?: (event: React$1.MouseEvent<HTMLButtonElement> | undefined) => void;
+    onStart?: (event: React__default.MouseEvent<HTMLButtonElement> | undefined) => void;
     onCompleted?: () => void;
-    onError?: (error: any) => void;
+    onError?: (error: Error) => void;
 }
-declare const AuthDownloadLink: React$1.FC<AuthDownloadLinkProps>;
+declare const AuthDownloadLink: React__default.FC<AuthDownloadLinkProps>;
 
 interface DialogProps {
     open: boolean;
@@ -324,89 +325,123 @@ interface DialogProps {
     fullWidth?: boolean;
     fullHeight?: boolean;
     className?: string;
-    children?: React$1.ReactNode;
+    children?: React__default.ReactNode;
     onClose?: (() => void);
 }
-declare const Dialog: React$1.FC<DialogProps>;
+declare const Dialog: React__default.FC<DialogProps>;
 
-interface DialogContentProps$2 {
+interface DialogContentProps {
     className?: string;
-    children?: React$1.ReactNode;
+    children?: React__default.ReactNode;
 }
-declare const DialogContent$1: React$1.FC<DialogContentProps$2>;
+declare const DialogContent: React__default.FC<DialogContentProps>;
 
 interface DialogFooterProps {
     className?: string;
-    children?: React$1.ReactNode;
+    children?: React__default.ReactNode;
 }
-declare const DialogFooter: React$1.FC<DialogFooterProps>;
+declare const DialogFooter: React__default.FC<DialogFooterProps>;
 
 interface DialogHeaderProps {
     className?: string;
-    children?: React$1.ReactNode;
+    children?: React__default.ReactNode;
 }
-declare const DialogHeader: React$1.FC<DialogHeaderProps>;
+declare const DialogHeader: React__default.FC<DialogHeaderProps>;
 
-interface DialogContentProps$1 {
+interface DialogTitleProps {
     className?: string;
-    children?: React$1.ReactNode;
+    children?: React__default.ReactNode;
     closeDisable?: boolean;
     onClose?: (() => void);
 }
-declare const DialogContent: React$1.FC<DialogContentProps$1>;
+declare const DialogTitle: React__default.FC<DialogTitleProps>;
 
-interface DialogContentProps {
+interface DialogActionsProps {
     className?: string;
-    children?: React$1.ReactNode;
+    children?: React__default.ReactNode;
 }
-declare const DialogActions: React$1.FC<DialogContentProps>;
+declare const DialogActions: React__default.FC<DialogActionsProps>;
 
 interface ConfirmDialogProps {
     title: string;
     ok?: string;
     cancel?: string;
-    children?: React$1.ReactNode;
+    children?: React__default.ReactNode;
     className?: string;
     onClose?: (isOk: boolean) => void;
 }
-declare const ConfirmDialog: React$1.FC<ConfirmDialogProps>;
+declare const ConfirmDialog: React__default.FC<ConfirmDialogProps>;
 
 interface ErrorDialogProps {
     title: string;
     ok?: string;
-    children?: React$1.ReactNode;
+    children?: React__default.ReactNode;
     className?: string;
     onClose?: (isOk: boolean) => void;
 }
-declare const ErrorDialog: React$1.FC<ErrorDialogProps>;
+declare const ErrorDialog: React__default.FC<ErrorDialogProps>;
 
 interface WarningDialogProps {
     title: string;
     ok?: string;
-    children?: React$1.ReactNode;
+    children?: React__default.ReactNode;
     className?: string;
     onClose?: (isOk: boolean) => void;
 }
-declare const WarningDialog: React$1.FC<WarningDialogProps>;
+declare const WarningDialog: React__default.FC<WarningDialogProps>;
 
 interface Props$3 {
     className?: string;
 }
-declare const ChevronDownIcon: React$1.FC<Props$3>;
+declare const ChevronDownIcon: React__default.FC<Props$3>;
 
 interface Props$2 {
     className?: string;
 }
-declare const ChevronRightIcon: React$1.FC<Props$2>;
+declare const ChevronRightIcon: React__default.FC<Props$2>;
 
 interface Props$1 {
     className?: string;
 }
-declare const ChevronLeftIcon: React$1.FC<Props$1>;
+declare const ChevronLeftIcon: React__default.FC<Props$1>;
 
 interface Props {
     className?: string;
 }
-declare const CrossIcon: React$1.FC<Props>;
-
-export { AuthDownloadLink, BarLoader, Button, Camera, ChevronDownIcon, ChevronLeftIcon, ChevronRightIcon, ConfirmDialog, ContextMenu, CrossIcon, Dialog, DialogActions, DialogContent$1 as DialogContent, DialogFooter, DialogHeader, DialogContent as DialogTitle, Divider, DomContainer, ErrorDialog, Map, Menu, MenuGroup, MenuItem, Popper, PopupMenu, Scanner, Selected, Spinner, TagInput, ToggleButton, Tooltip, WarningDialog };
+declare const CrossIcon: React__default.FC<Props>;
+
+/**
+ * Utility type pour créer des props avec ref pour la compatibilité React 18/19
+ * En React 19, ref est passé directement dans les props
+ * En React 18, ref est passé séparément via forwardRef
+ */
+type ForwardRefProps<T, P = object> = P & {
+    ref?: React$1.Ref<T>;
+};
+/**
+ * Type pour la fonction de rendu compatible React 18/19
+ */
+type ForwardRefRenderFunction<T, P> = (props: P, ref: React$1.ForwardedRef<T>) => React$1.ReactElement | null;
+/**
+ * Composant wrapper compatible React 18 et React 19
+ *
+ * Utilise la signature standard de React.forwardRef qui est compatible
+ * avec les deux versions de React.
+ *
+ * @example
+ * ```tsx
+ * interface MyComponentProps {
+ *   className?: string;
+ *   children?: React.ReactNode;
+ * }
+ *
+ * const MyComponent = forwardRef<HTMLDivElement, MyComponentProps>(
+ *   (props, ref) => (
+ *     <div ref={ref} className={props.className}>{props.children}</div>
+ *   )
+ * );
+ * ```
+ */
+declare function forwardRef<T, P>(render: ForwardRefRenderFunction<T, P>): React$1.ForwardRefExoticComponent<React$1.PropsWithoutRef<P> & React$1.RefAttributes<T>>;
+
+export { AuthDownloadLink, BarLoader, Button, Camera, ChevronDownIcon, ChevronLeftIcon, ChevronRightIcon, ConfirmDialog, ContextMenu, CrossIcon, Dialog, DialogActions, DialogContent, DialogFooter, DialogHeader, DialogTitle, Divider, DomContainer, ErrorDialog, ForwardRefProps, ForwardRefRenderFunction, Map, Menu, MenuGroup, MenuItem, Popper, PopupMenu, Scanner, Selected, Spinner, TagInput, ToggleButton, Tooltip, WarningDialog, forwardRef };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cortex-react-ui",
-  "version": "0.2.16",
+  "version": "0.2.17",
   "description": "React UI",
   "author": "Anthony",
   "license": "MIT",
@@ -81,15 +81,15 @@
     "@storybook/react": "^8.4.7",
     "@storybook/react-webpack5": "8.4.7",
     "@testing-library/jest-dom": "^5.11.4",
-    "@testing-library/react": "^11.1.0",
-    "@testing-library/user-event": "^12.1.10",
+    "@testing-library/react": "^14.0.0",
+    "@testing-library/user-event": "^14.0.0",
     "@types/jest": "^26.0.15",
     "@types/leaflet": "^1.7.10",
     "@types/leaflet-draw": "^1.0.11",
     "@types/leaflet.fullscreen": "^1.6.1",
     "@types/node": "^22.10.5",
-    "@types/react": "^17.0.0",
-    "@types/react-dom": "^17.0.0",
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^18.2.0",
     "@yudiel/react-qr-scanner": "2.1.0",
     "css-loader": "5.2.6",
     "eslint-config-airbnb": "^18.2.1",