cortex-react-ui 0.2.22 → 0.2.24

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

@@ -0,0 +1 @@
+export default function classNames(...values: any[]): string;

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

@@ -0,0 +1,9 @@
+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/useClickOutside.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export default function useClickOutside(callback: () => void, nodes: (string | HTMLElement | React.RefObject<HTMLElement>)[]): void;

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

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export default function useElement(element: string | HTMLElement | React.RefObject<HTMLElement> | undefined): HTMLElement | undefined;

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

@@ -0,0 +1,10 @@
+import * as React from 'react';
+/**
+ * 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

@@ -0,0 +1,447 @@
+import * as React 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';
+import { ControlPosition, DrawEvents, LatLngTuple } from 'leaflet';
+
+declare const PopperPlacement: {
+    readonly Center: "center";
+    readonly BottomCenter: "bottom-center";
+    readonly BottomRight: "bottom-right";
+    readonly BottomLeft: "bottom-left";
+    readonly TopCenter: "top-center";
+    readonly TopRight: "top-right";
+    readonly TopLeft: "top-left";
+    readonly LeftTop: "left-top";
+    readonly LeftBottom: "left-bottom";
+    readonly LeftCenter: "left-center";
+    readonly RightTop: "right-top";
+    readonly RightBottom: "right-bottom";
+    readonly RightCenter: "right-center";
+};
+type Props$5 = {
+    anchorEl?: string | HTMLElement | React__default.RefObject<HTMLElement>;
+    anchorPosition?: {
+        top: number;
+        left: number;
+    };
+    placement?: ObjectValues<typeof PopperPlacement>;
+    open?: boolean;
+    role?: string;
+    children?: React__default.ReactNode;
+    className?: string;
+    overflow?: boolean;
+    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__default.ForwardRefExoticComponent<Props$5 & React__default.RefAttributes<HTMLElement>>;
+
+type Props$4 = {
+    children?: React__default.ReactNode;
+    container?: HTMLElement | (() => HTMLElement);
+};
+declare const DomContainer: React__default.ForwardRefExoticComponent<Props$4 & React__default.RefAttributes<HTMLElement>>;
+
+interface SpinnerProps {
+    className?: string;
+    variant?: 'indeterminate' | 'determinate';
+}
+declare const Spinner: React__default.FC<SpinnerProps>;
+
+interface BarLoaderProps {
+    title?: string;
+    color?: 'red' | 'blue' | 'yellow' | 'orange' | 'green';
+    className?: string;
+    isComplete: boolean;
+}
+declare const BarLoader: React__default.FC<BarLoaderProps>;
+
+interface SelectedProps {
+    title?: string;
+    data: any[];
+    onClick: (elt: any) => void;
+}
+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__default.ReactNode;
+    onClick?: (event: React__default.MouseEvent<HTMLButtonElement>) => void;
+}
+declare const Button: React__default.FC<ButtonProps>;
+
+type TScanConfirmDialogLabels = {
+    title?: string;
+    message?: string;
+    btnOk?: {
+        label: string;
+        style?: React__default.CSSProperties;
+    };
+    btnCancel?: {
+        label: string;
+        style?: React__default.CSSProperties;
+    };
+};
+
+declare const Scanner: React__default.FC<ScannerProps>;
+type TScanTrackerType = 'outline' | 'boundingBox' | 'centerText';
+type ScannerProps = {
+    scanConfirmation?: boolean;
+    scanConfirmDialog?: TScanConfirmDialogLabels;
+    scanTrackerType?: TScanTrackerType;
+    onScan?: (detectedCodes: IDetectedBarcode[]) => void;
+} & IScannerProps;
+
+declare const Camera: React__default.FC<CameraProps>;
+type CameraProps = {
+    onCapture: ({ fileStoreName, fileRowId, file }: TfileCapturedProps) => void;
+    mode?: 'photo' | 'video';
+    isOffline?: boolean;
+    isShowOffline?: boolean;
+    validateText?: string;
+    resetText?: string;
+    isShowVideoButton?: boolean;
+    isShowSwitchButton?: boolean;
+} & Partial<WebcamProps>;
+type TfileCapturedProps = {
+    fileStoreName?: string | null;
+    fileRowId?: number | null;
+    file?: File | null;
+    imageSrc?: string | null;
+    videoSrc?: string | null;
+};
+
+interface ToggleButtonProps {
+    selected?: boolean;
+    value?: string;
+    className?: string;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    children?: React__default.ReactNode;
+    onChange?: (value: string | undefined) => void;
+}
+declare const ToggleButton: React__default.FC<ToggleButtonProps>;
+
+interface TooltipProps$1 {
+    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__default.FC<TooltipProps$1>;
+
+declare namespace Cortex {
+    type Tag = {
+        id: string;
+        label: string;
+        value: any;
+    };
+    type TagSuggestion = {
+        id: string;
+        label: string;
+        value?: any;
+        group?: boolean;
+        suggestions?: TagSuggestion[];
+    };
+}
+
+interface TooltipProps {
+    tags?: Cortex.Tag[];
+    className?: string;
+    suggestions?: Cortex.TagSuggestion[];
+    disableFilter?: boolean;
+    onTextChange?: (text: string) => void;
+    onChange?: (tags: Cortex.Tag[]) => void;
+}
+declare const TagInput: React__default.FC<TooltipProps>;
+
+declare class Point {
+    id: number;
+    order: number;
+    latitude: number;
+    longitude: number;
+}
+
+declare class Location {
+    id: number;
+    objId: string;
+    points: Point[];
+}
+
+type CenterActiveAreaControlProps = {
+    autoCenter?: boolean;
+};
+
+/** Props interface for MapFullscreenControl component */
+type MapFullscreenControlProps = {
+    /** Change the content of the button, can be HTML, default null */
+    content?: string | undefined;
+    /** Change the position of the button can be topleft, topright, bottomright or bottomleft, default topleft */
+    position?: ControlPosition | undefined;
+    /** Change the title of the button, default Full Screen */
+    title?: string | undefined;
+    /** Change the title of the button when fullscreen is on, default Exit Full Screen */
+    titleCancel?: string | undefined;
+    /** Force separate button to detach from zoom buttons, default false */
+    forceSeparateButton?: boolean | undefined;
+    /** Force use of pseudo full screen even if full screen API is available, default false */
+    forcePseudoFullscreen?: boolean | undefined;
+    /** Use pseudo fullscreen */
+    pseudoFullscreen?: boolean | undefined;
+    /** Dom element to render in full screen, false by default, fallback to map._container */
+    fullscreenElement?: false | HTMLElement | undefined;
+};
+
+type DrawToolsProps = {
+    position?: ControlPosition | undefined;
+    handleOnCreated?: (v: DrawEvents.Created) => void;
+    handleOnDeleted?: (v: DrawEvents.Deleted) => void;
+    handleOnEdited?: (v: DrawEvents.Edited) => void;
+    draw?: drawType;
+    editable?: boolean;
+};
+type drawType = {
+    polyline?: boolean;
+    polygon?: boolean;
+    rectangle?: boolean;
+    circle?: boolean;
+    marker?: boolean;
+    circlemarker?: boolean;
+};
+
+type MapsProps = {
+    MapContainerProps?: MapContainerProps;
+    center?: LatLngTuple;
+    fullscreen?: MapFullscreenControlProps | boolean;
+    centerActiveArea?: CenterActiveAreaControlProps | boolean;
+    drawTools?: DrawToolsProps | boolean;
+    minZoom?: number;
+    maxZoom?: number;
+    zoom?: number;
+    data?: Location[];
+    toggleSatelliteView?: boolean;
+    singlePosition?: boolean;
+    onChange?: (locations: Location[]) => void;
+};
+
+declare const Map: React__default.FC<AppProps>;
+type AppProps = MapsProps & {
+    onClose?: (() => void);
+    onSave?: ((locations: Location[]) => void);
+    onChange?: ((locations: Location[]) => void);
+    customButtons?: {
+        cancelButton?: HTMLElement;
+        saveButton?: HTMLElement;
+    };
+};
+
+interface MenuProps {
+    containerRef: React__default.RefObject<HTMLElement>;
+    className?: string;
+    children?: React__default.ReactNode;
+    onClose?: () => void;
+    onClick?: (event: React__default.MouseEvent<HTMLUListElement> | undefined) => void;
+}
+declare const Menu: React__default.FC<MenuProps>;
+
+interface ContextMenuProps {
+    className?: string;
+    children?: React__default.ReactNode;
+    open?: boolean;
+    placement?: ObjectValues<typeof PopperPlacement>;
+    container?: string | HTMLElement | React__default.RefObject<HTMLElement>;
+    onOpen?: () => void;
+    onClose?: () => void;
+}
+declare const ContextMenu: React__default.FC<ContextMenuProps>;
+
+interface DividerProps {
+    className?: string;
+}
+declare const Divider: React__default.FC<DividerProps>;
+
+interface MenuItemProps {
+    className?: string;
+    style?: CSSProperties | undefined;
+    children?: React__default.ReactNode;
+    label?: string;
+    icon?: React__default.ReactNode;
+    active?: boolean;
+    disable?: boolean;
+    itemTemplate?: React__default.ReactNode;
+    onClick?: (event: React__default.MouseEvent<HTMLButtonElement> | undefined) => void;
+}
+declare const MenuItem: React__default.FC<MenuItemProps>;
+
+interface PopupMenuProps {
+    className?: string;
+    children?: React__default.ReactNode;
+    open?: boolean;
+    placement?: ObjectValues<typeof PopperPlacement>;
+    anchorPosition?: {
+        top: number;
+        left: number;
+    };
+    anchorEl?: string | HTMLElement | React__default.RefObject<HTMLElement>;
+    onClose?: () => void;
+}
+declare const PopupMenu: React__default.FC<PopupMenuProps>;
+
+interface MenuGroupProps {
+    title?: string;
+    className?: string;
+    children?: React__default.ReactNode;
+}
+declare const MenuGroup: React__default.FC<MenuGroupProps>;
+
+interface AuthDownloadLinkProps {
+    url: string;
+    queryParams?: {
+        [key: string]: string | number | boolean;
+    };
+    token: string;
+    label?: string;
+    onStart?: (event: React__default.MouseEvent<HTMLButtonElement> | undefined) => void;
+    onCompleted?: () => void;
+    onError?: (error: Error) => void;
+}
+declare const AuthDownloadLink: React__default.FC<AuthDownloadLinkProps>;
+
+interface DialogProps {
+    open: boolean;
+    width?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    fullWidth?: boolean;
+    fullHeight?: boolean;
+    className?: string;
+    children?: React__default.ReactNode;
+    onClose?: (() => void);
+}
+declare const Dialog: React__default.FC<DialogProps>;
+
+interface DialogContentProps {
+    className?: string;
+    children?: React__default.ReactNode;
+}
+declare const DialogContent: React__default.FC<DialogContentProps>;
+
+interface DialogFooterProps {
+    className?: string;
+    children?: React__default.ReactNode;
+}
+declare const DialogFooter: React__default.FC<DialogFooterProps>;
+
+interface DialogHeaderProps {
+    className?: string;
+    children?: React__default.ReactNode;
+}
+declare const DialogHeader: React__default.FC<DialogHeaderProps>;
+
+interface DialogTitleProps {
+    className?: string;
+    children?: React__default.ReactNode;
+    closeDisable?: boolean;
+    onClose?: (() => void);
+}
+declare const DialogTitle: React__default.FC<DialogTitleProps>;
+
+interface DialogActionsProps {
+    className?: string;
+    children?: React__default.ReactNode;
+}
+declare const DialogActions: React__default.FC<DialogActionsProps>;
+
+interface ConfirmDialogProps {
+    title: string;
+    ok?: string;
+    cancel?: string;
+    children?: React__default.ReactNode;
+    className?: string;
+    onClose?: (isOk: boolean) => void;
+}
+declare const ConfirmDialog: React__default.FC<ConfirmDialogProps>;
+
+interface ErrorDialogProps {
+    title: string;
+    ok?: string;
+    children?: React__default.ReactNode;
+    className?: string;
+    onClose?: (isOk: boolean) => void;
+}
+declare const ErrorDialog: React__default.FC<ErrorDialogProps>;
+
+interface WarningDialogProps {
+    title: string;
+    ok?: string;
+    children?: React__default.ReactNode;
+    className?: string;
+    onClose?: (isOk: boolean) => void;
+}
+declare const WarningDialog: React__default.FC<WarningDialogProps>;
+
+interface Props$3 {
+    className?: string;
+}
+declare const ChevronDownIcon: React__default.FC<Props$3>;
+
+interface Props$2 {
+    className?: string;
+}
+declare const ChevronRightIcon: React__default.FC<Props$2>;
+
+interface Props$1 {
+    className?: string;
+}
+declare const ChevronLeftIcon: React__default.FC<Props$1>;
+
+interface Props {
+    className?: string;
+}
+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.Ref<T>;
+};
+/**
+ * Type pour la fonction de rendu compatible React 18/19
+ */
+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>
+ *   )
+ * );
+ * ```
+ */
+declare function forwardRef<T, P>(render: ForwardRefRenderFunction<T, P>): React.ForwardRefExoticComponent<React.PropsWithoutRef<P> & React.RefAttributes<T>>;
+
+export { AuthDownloadLink, BarLoader, Button, Camera, ChevronDownIcon, ChevronLeftIcon, ChevronRightIcon, ConfirmDialog, ContextMenu, CrossIcon, Dialog, DialogActions, DialogContent, DialogFooter, DialogHeader, DialogTitle, Divider, DomContainer, ErrorDialog, Map, Menu, MenuGroup, MenuItem, Popper, PopupMenu, Scanner, Selected, Spinner, TagInput, ToggleButton, Tooltip, WarningDialog, forwardRef };
+export type { ForwardRefProps, ForwardRefRenderFunction };

package/lib/styles/BarLoader/index.scss

@@ -0,0 +1,132 @@
+@use "../global.scss";
+
+@mixin barLoader($props: null, $options: null) {
+  $internal-options: global.$default-options;
+
+  $internal-props: ();
+
+  $internal-props: global.safe-map-merge($internal-props, $props);
+  $internal-options: global.safe-map-merge($internal-options, $options);
+
+  .loader { 
+    position:relative;
+    padding:2px;
+    text-align: center;
+    font-size: 15px;
+    font-weight: bold;
+  
+    :before {
+      content:'';
+      position:absolute;
+      top:-1px; 
+      right:-4px; 
+      bottom:-1px; 
+      left:-4px;
+    }
+  
+    &.loader-color-red{
+      background-color:rgba(255, 0, 0, 0.2);
+    
+      &.completed{
+        z-index: 3;
+        background: red !important;
+      }
+    }
+
+    &.loader-color-green{
+      background-color:rgba(0, 128, 0, 0.2);
+    
+      &.completed{
+        z-index: 3;
+        background: lightgreen !important;
+      }
+    }
+  
+    &.loader-color-yellow{
+      background-color:rgba(0, 255, 0, 0.2);
+    
+      &.completed{
+        z-index: 3;
+        background: yellow !important;
+      }
+    }
+  
+    &.loader-color-blue{
+      background-color:rgba(14, 190, 255, 0.2);
+    
+      &.completed{
+        z-index: 3;
+        background: #0ebeff !important;
+      }
+    }
+  
+    &.loader-color-orange{
+      background-color:rgba(255, 165, 0, 0.2);
+    
+      &.completed{
+        z-index: 3;
+        background: orange !important;
+      }
+    }
+  }
+  
+  .loaderBar { 
+    position:absolute;
+    top:0;
+    right:100%;
+    bottom:0;
+    left:0;
+    background:#0ebeff; 
+    width:0;
+    animation:borealisBar 1s linear infinite;
+    z-index: 2;
+  
+    &.loaderBar-color-red{
+      background:red !important; 
+    }
+  
+    &.loaderBar-color-blue{
+      background:#0ebeff !important; 
+    }
+  
+    &.loaderBar-color-yellow{
+      background:yellow !important; 
+    }
+  
+    &.loaderBar-color-orange{
+      background:orange !important; 
+    }
+
+    &.loaderBar-color-green{
+      background:lightgreen !important; 
+    }
+  }
+  
+  .loaderBar-title{
+    text-align: center;
+    padding-top: 2px
+  }
+  
+  @keyframes borealisBar {
+    0% {
+      left:0%;
+      right:100%;
+      width:0%;
+    }
+    10% {
+      left:0%;
+      right:75%;
+      width:25%;
+    }
+    90% {
+      right:0%;
+      left:75%;
+      width:25%;
+    }
+    100% {
+      left:100%;
+      right:0%;
+      width:0%;
+    }
+  }
+}