@axa-fr/canopee-react 1.0.0-alpha.1089

package/dist/distributeur/Form/Textarea/Textarea.d.ts

@@ -0,0 +1,5 @@
+import "@axa-fr/canopee-css/distributeur/Form/Textarea/Textarea.css";
+declare const Textarea: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, "ref"> & {
+    classModifier?: string;
+} & import("react").RefAttributes<HTMLTextAreaElement>>;
+export { Textarea };

package/dist/distributeur/Form/Textarea/Textarea.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import "@axa-fr/canopee-css/distributeur/Form/Textarea/Textarea.css";
+import { forwardRef, useId } from "react";
+import { getComponentClassName } from "../../utilities";
+const Textarea = forwardRef(({ id, className, classModifier, ...otherProps }, inputRef) => {
+    const inputUseId = useId();
+    const inputId = id ?? inputUseId;
+    const componentClassName = getComponentClassName(className, classModifier, "af-form__input-textarea");
+    return (_jsx("textarea", { ...otherProps, id: inputId, className: componentClassName, ref: inputRef, required: classModifier?.includes("required") }));
+});
+Textarea.displayName = "Textarea";
+export { Textarea };

package/dist/distributeur/Form/Textarea/TextareaInput.d.ts

@@ -0,0 +1,7 @@
+import "@axa-fr/canopee-css/distributeur/Form/Textarea/Textarea.css";
+import { ComponentProps } from "react";
+import { type ConsumerFieldProps } from "../core";
+import { Textarea } from "./Textarea";
+type Props = ConsumerFieldProps & ComponentProps<typeof Textarea>;
+declare const TextareaInput: import("react").ForwardRefExoticComponent<Omit<Props, "ref"> & import("react").RefAttributes<HTMLTextAreaElement>>;
+export { TextareaInput };

package/dist/distributeur/Form/Textarea/TextareaInput.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import "@axa-fr/canopee-css/distributeur/Form/Textarea/Textarea.css";
+import { forwardRef } from "react";
+import { Field } from "../core";
+import { Textarea } from "./Textarea";
+const TextareaInput = forwardRef(({ label, children, ...props }, inputRef) => {
+    return (_jsx(Field, { label: label, labelPosition: "top", classNameSuffix: "textarea", ...props, renderInput: ({ id, ariaInvalid, errorId, ...inputProps }) => (_jsxs(_Fragment, { children: [_jsx(Textarea, { id: id, ref: inputRef, "aria-describedby": errorId, "aria-invalid": ariaInvalid, ...inputProps }), children] })) }));
+});
+TextareaInput.displayName = "TextareaInput";
+export { TextareaInput };

package/dist/distributeur/Form/Textarea/index.d.ts

@@ -0,0 +1,2 @@
+export { TextareaInput } from "./TextareaInput";
+export { Textarea } from "./Textarea";

package/dist/distributeur/Form/Textarea/index.js

@@ -0,0 +1,2 @@
+export { TextareaInput } from "./TextareaInput";
+export { Textarea } from "./Textarea";

package/dist/distributeur/Form/core/Deprecated/Field.d.ts

@@ -0,0 +1,21 @@
+import { type ComponentPropsWithoutRef, type ReactNode } from "react";
+import { FieldForm } from "./FieldForm";
+type FieldProps = Omit<ComponentPropsWithoutRef<typeof FieldForm>, "children"> & {
+    label: ReactNode;
+    children?: ReactNode;
+    id?: string;
+    classModifier?: string;
+    classNameContainerLabel?: string;
+    classNameContainerInput?: string;
+    isVisible?: boolean;
+    roleContainer?: string;
+    ariaLabelContainer?: string;
+    isLabelContainerLinkedToInput?: boolean;
+    errorId?: string;
+};
+/**
+ * @deprecated This component is deprecated and will be removed in future versions. Use components with labels instead, such as `TextInput`
+ * or `SelectInput`.
+ */
+export declare const LegacyField: ({ id, message, messageType, label, children, forceDisplayMessage, classModifier, className, classNameContainerLabel, classNameContainerInput, isVisible, roleContainer, ariaLabelContainer, isLabelContainerLinkedToInput, errorId, }: FieldProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/distributeur/Form/core/Deprecated/Field.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import classNames from "classnames";
+import { getComponentClassName } from "../../../utilities";
+import { FieldError } from "../FieldError";
+import { MessageTypes } from "../MessageTypes";
+import { FieldForm } from "./FieldForm";
+/**
+ * @deprecated This component is deprecated and will be removed in future versions. Use components with labels instead, such as `TextInput`
+ * or `SelectInput`.
+ */
+export const LegacyField = ({ id = "", message = "", messageType = MessageTypes.error, label, children, forceDisplayMessage, classModifier = "", className, classNameContainerLabel = "col-md-2", classNameContainerInput = "col-md-10", isVisible = true, roleContainer, ariaLabelContainer, isLabelContainerLinkedToInput = true, errorId, }) => {
+    if (!isVisible) {
+        return null;
+    }
+    const componentClassName = getComponentClassName(className, classModifier, "row af-form__group");
+    return (_jsxs("div", { className: componentClassName, role: roleContainer, "aria-label": ariaLabelContainer, children: [_jsx("div", { className: classNameContainerLabel, children: _jsx("label", { className: classNames({
+                        "af-form__group-label--required": classModifier.includes("required"),
+                    }, "af-form__group-label"), htmlFor: isLabelContainerLinkedToInput ? id : undefined, children: label }) }), _jsxs(FieldForm, { className: classNameContainerInput, message: message, messageType: messageType, forceDisplayMessage: forceDisplayMessage, children: [children, _jsx(FieldError, { message: message, messageType: messageType, errorId: errorId })] })] }));
+};

package/dist/distributeur/Form/core/Deprecated/FieldForm.d.ts

@@ -0,0 +1,103 @@
+import { type BaseSyntheticEvent, type Dispatch, type ReactElement, type ReactNode, type SetStateAction } from "react";
+import { FormClassManager } from "../FormClassManager";
+import { MessageTypes } from "../MessageTypes";
+type TMessage = {
+    message?: string;
+    messageType?: MessageTypes;
+};
+declare const INITIAL_STATE: {
+    hasLostFocusOnce: boolean;
+    hasFocus: boolean;
+    hasChange: boolean;
+    memory: TMessage;
+};
+type EventFunction = {
+    onChange?: (event: BaseSyntheticEvent) => void;
+    onBlur?: (event: BaseSyntheticEvent) => void;
+    onFocus?: (event: BaseSyntheticEvent) => void;
+};
+type FieldFormProps = TMessage & {
+    className?: string;
+    classModifier?: string;
+    forceDisplayMessage?: boolean;
+    children: ReactNode;
+    setStateMemoryFn?: typeof setStateMemory;
+    onChangeByStateFn?: typeof onChangeByState;
+    setStateOnBlurFn?: typeof setStateOnBlur;
+    setStateOnFocusFn?: typeof setStateOnFocus;
+    initialState?: typeof INITIAL_STATE;
+};
+type SetState = (prevState: typeof INITIAL_STATE) => typeof INITIAL_STATE;
+export declare const setStateMemory: ({ message, messageType }: TMessage) => SetState;
+export declare const setStateHasChange: () => SetState;
+export declare const onChangeByState: (setState: Dispatch<SetStateAction<{
+    hasLostFocusOnce: boolean;
+    hasFocus: boolean;
+    hasChange: boolean;
+    memory: TMessage;
+}>>, stateHasChange: boolean, setStateHasChangeFn?: () => SetState) => false | void;
+export declare const setStateOnBlur: () => SetState;
+export declare const setStateOnFocus: ({ message, messageType }: TMessage) => SetState;
+type GetMessageInfoProps = typeof INITIAL_STATE & Required<Pick<FieldFormProps, "message" | "messageType" | "forceDisplayMessage">>;
+export declare const getMessageInfo: ({ forceDisplayMessage, hasLostFocusOnce, hasFocus, memory, hasChange, message, messageType, }: GetMessageInfoProps) => Pick<FieldFormProps, "message" | "messageType">;
+type EventWrapperProps = {
+    props: EventFunction;
+} & Pick<AddPropsClone, "wrapper">;
+export declare const eventWrapper: ({ wrapper, props }: EventWrapperProps) => {
+    onChange: (ev: BaseSyntheticEvent) => void;
+    onBlur: (ev: BaseSyntheticEvent) => void;
+    onFocus: (ev: BaseSyntheticEvent) => void;
+};
+type AddPropsClone = Omit<RenderChildrenProps, "children"> & {
+    child: ReactElement<Record<string, unknown>>;
+    classModifier: string;
+    name: string;
+    getMessageClassModifierFn?: typeof FormClassManager.getMessageClassModifier;
+    eventWrapperFn?: ({ wrapper, props }: EventWrapperProps) => {
+        onChange: (ev: BaseSyntheticEvent) => void;
+        onBlur: (ev: BaseSyntheticEvent) => void;
+        onFocus: (ev: BaseSyntheticEvent) => void;
+    };
+};
+export declare const addPropsClone: ({ message, messageType, classModifier, wrapper, child, name, getMessageClassModifierFn, eventWrapperFn, }: AddPropsClone) => {
+    isVisible: boolean;
+    message?: undefined;
+    classModifier?: undefined;
+} | {
+    message: string | undefined;
+    isVisible?: undefined;
+    classModifier?: undefined;
+} | {
+    classModifier: string;
+    isVisible?: undefined;
+    message?: undefined;
+} | {
+    classModifier: string;
+    onChange: (ev: BaseSyntheticEvent) => void;
+    onBlur: (ev: BaseSyntheticEvent) => void;
+    onFocus: (ev: BaseSyntheticEvent) => void;
+    isVisible?: undefined;
+    message?: undefined;
+} | {
+    onChange: (ev: BaseSyntheticEvent) => void;
+    onBlur: (ev: BaseSyntheticEvent) => void;
+    onFocus: (ev: BaseSyntheticEvent) => void;
+    isVisible?: undefined;
+    message?: undefined;
+    classModifier?: undefined;
+} | {
+    isVisible?: undefined;
+    message?: undefined;
+    classModifier?: undefined;
+};
+type RenderChildrenProps = {
+    wrapper: EventFunction;
+} & Partial<Pick<FieldFormProps, "children">> & ReturnType<typeof getMessageInfo>;
+export declare const renderedChildren: ({ children, wrapper, message, messageType, }: RenderChildrenProps) => ReactNode;
+/**
+ * @deprecated This component is deprecated and will be removed in future versions.
+ * This was an internal component used to manage the state of the form fields.
+ * It is not recommended to use it directly in your code as it is not a public API.
+ */
+export declare const FieldForm: ({ children, message, messageType, className, classModifier, forceDisplayMessage, setStateMemoryFn, onChangeByStateFn, setStateOnBlurFn, setStateOnFocusFn, initialState, }: FieldFormProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/distributeur/Form/core/Deprecated/FieldForm.js

@@ -0,0 +1,162 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Children, cloneElement, isValidElement, useEffect, useRef, useState, } from "react";
+import { getComponentClassName } from "../../../utilities";
+import { FormClassManager } from "../FormClassManager";
+import { MessageTypes } from "../MessageTypes";
+const defaultClassName = "md-10";
+const INITIAL_STATE = {
+    hasLostFocusOnce: false,
+    hasFocus: false,
+    hasChange: false,
+    memory: { message: "", messageType: MessageTypes.error },
+};
+export const setStateMemory = ({ message, messageType = MessageTypes.error }) => (prevState) => ({
+    ...prevState,
+    memory: {
+        message,
+        messageType,
+    },
+});
+export const setStateHasChange = () => (prevState) => ({
+    ...prevState,
+    hasChange: true,
+});
+export const onChangeByState = (setState, stateHasChange, setStateHasChangeFn = setStateHasChange) => !stateHasChange && setState(setStateHasChangeFn());
+export const setStateOnBlur = () => (prevState) => ({
+    ...prevState,
+    hasLostFocusOnce: true,
+    hasFocus: false,
+});
+export const setStateOnFocus = ({ message, messageType = MessageTypes.error }) => (prevState) => ({
+    ...prevState,
+    hasFocus: true,
+    memory: { message, messageType },
+});
+export const getMessageInfo = ({ forceDisplayMessage, hasLostFocusOnce, hasFocus, memory, hasChange, message, messageType, }) => {
+    const isDisplayMessage = hasLostFocusOnce || forceDisplayMessage || (hasChange && !hasFocus);
+    if (!isDisplayMessage) {
+        return {
+            message: "",
+            messageType: "",
+        };
+    }
+    return hasFocus
+        ? memory
+        : {
+            message,
+            messageType,
+        };
+};
+export const eventWrapper = ({ wrapper, props }) => ({
+    onChange: (ev) => {
+        wrapper?.onChange?.(ev);
+        if (props.onChange) {
+            props.onChange(ev);
+        }
+    },
+    onBlur: (ev) => {
+        wrapper?.onBlur?.(ev);
+        if (props.onBlur) {
+            props.onBlur(ev);
+        }
+    },
+    onFocus: (ev) => {
+        wrapper?.onFocus?.(ev);
+        if (props.onFocus) {
+            props.onFocus(ev);
+        }
+    },
+});
+export const addPropsClone = ({ message, messageType, classModifier, wrapper, child, name, getMessageClassModifierFn = FormClassManager.getMessageClassModifier, eventWrapperFn = eventWrapper, }) => {
+    const messageClassModifier = getMessageClassModifierFn(messageType, message, classModifier);
+    const displayName = child.type.displayName ?? name;
+    switch (displayName) {
+        case "HelpMessage":
+            return { isVisible: !message };
+        case "FieldError":
+            return { message };
+        case "FieldInput":
+            return { classModifier: messageClassModifier };
+        case "EnhancedInputRadio":
+        case "EnhancedInputCheckbox":
+            return {
+                ...eventWrapperFn({ wrapper, props: child.props }),
+                classModifier: messageClassModifier,
+            };
+        case "EnhancedInput":
+            return {
+                ...eventWrapperFn({ wrapper, props: child.props }),
+            };
+        default:
+            return {};
+    }
+};
+export const renderedChildren = ({ children, wrapper, message, messageType, }) => Children.map(children, (child) => {
+    if (!isValidElement(child) || typeof child.type === "string") {
+        return child;
+    }
+    const props = {
+        ...child.props,
+    };
+    if (child.props.children) {
+        const subChildren = renderedChildren({
+            children: child.props
+                .children,
+            wrapper,
+            message,
+            messageType,
+        });
+        if (subChildren !== null) {
+            props.children = subChildren;
+        }
+    }
+    return cloneElement(child, {
+        ...props,
+        ...addPropsClone({
+            ...child.type,
+            name: child.type.name,
+            message,
+            messageType,
+            classModifier: props.classModifier,
+            wrapper,
+            child: child,
+        }),
+    });
+});
+/**
+ * @deprecated This component is deprecated and will be removed in future versions.
+ * This was an internal component used to manage the state of the form fields.
+ * It is not recommended to use it directly in your code as it is not a public API.
+ */
+export const FieldForm = ({ children, message = "", messageType = MessageTypes.error, className = defaultClassName, classModifier = "", forceDisplayMessage = false, setStateMemoryFn = setStateMemory, onChangeByStateFn = onChangeByState, setStateOnBlurFn = setStateOnBlur, setStateOnFocusFn = setStateOnFocus, initialState = INITIAL_STATE, }) => {
+    const [state, setState] = useState(initialState);
+    const previousForceDisplayMessage = useRef(forceDisplayMessage);
+    useEffect(() => {
+        if (previousForceDisplayMessage.current !== forceDisplayMessage) {
+            setState(setStateMemoryFn({ message, messageType }));
+        }
+    }, [
+        forceDisplayMessage,
+        message,
+        messageType,
+        previousForceDisplayMessage,
+        setState,
+        setStateMemoryFn,
+    ]);
+    // for particular case on particular browers which does not throw onFocus or onBlur event
+    const onChange = () => onChangeByStateFn(setState, state?.hasChange);
+    const onBlur = () => setState(setStateOnBlurFn());
+    const onFocus = () => setState(setStateOnFocusFn({ message, messageType }));
+    const childrenCloned = renderedChildren({
+        children,
+        wrapper: { onFocus, onChange, onBlur },
+        ...getMessageInfo({
+            ...state,
+            forceDisplayMessage,
+            message,
+            messageType,
+        }),
+    });
+    const subComponentClassName = getComponentClassName(className, classModifier, defaultClassName);
+    return _jsx("div", { className: subComponentClassName, children: childrenCloned });
+};

package/dist/distributeur/Form/core/Deprecated/FieldInput.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from "react";
+type FieldProps = {
+    isVisible?: boolean;
+    className?: string;
+    classModifier?: string;
+    children?: ReactNode;
+};
+/**
+ * @deprecated This component is deprecated and will be removed in future versions.
+ * This was an internal component and it is not recommended to use it directly in your code as it is not a public API.
+ */
+export declare const FieldInput: {
+    ({ children, className, classModifier, isVisible, }: FieldProps): import("react/jsx-runtime").JSX.Element | null;
+    displayName: string;
+};
+export {};

package/dist/distributeur/Form/core/Deprecated/FieldInput.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { getComponentClassName } from "../../../utilities";
+/**
+ * @deprecated This component is deprecated and will be removed in future versions.
+ * This was an internal component and it is not recommended to use it directly in your code as it is not a public API.
+ */
+export const FieldInput = ({ children, className = "", classModifier = "", isVisible = true, }) => {
+    if (!isVisible) {
+        return null;
+    }
+    const newClassName = getComponentClassName(className, classModifier, "");
+    return _jsx("div", { className: newClassName, children: children });
+};
+FieldInput.displayName = "FieldInput";

package/dist/distributeur/Form/core/Field.d.ts

@@ -0,0 +1,80 @@
+import { type ReactNode } from "react";
+import { MessageTypes } from ".";
+type InputProps = {
+    /**
+     * The label of the input element.
+     */
+    label: ReactNode;
+    /**
+     * The id of the input element. If not provided, a unique id will be generated.
+     */
+    id?: string;
+    className?: string;
+    classModifier?: string;
+    classNameContainerLabel?: string;
+    classNameContainerInput?: string;
+    /**
+     * Setting this to false will disable the rendering of the component
+     * @default true
+     * @deprecated You should handle the visibility of the component in your code
+     * instead of using this prop. This prop will be removed in a future version.
+     */
+    isVisible?: boolean;
+    roleContainer?: string;
+    ariaLabelContainer?: string;
+    isLabelContainerLinkedToInput?: boolean;
+    forceDisplayMessage?: boolean;
+    message?: string;
+    messageType?: MessageTypes;
+    required?: boolean;
+    disabled?: boolean;
+    helpMessage?: ReactNode;
+    /**
+     * Sets the position of the label relative to the input.
+     * Top will put the label at the top of the input group. This is useful for textarea for example.
+     * Center will put the label in the center of the input group, and is used for single line inputs in order to align the label and the input box.
+     * @default "center"
+     *
+     */
+    labelPosition?: "top" | "center";
+    /**
+     * suffix appended to the className of the div wrapping the input
+     * @deprecated We should rationalize the CSS for the components to avoid having to use different sufixes
+     * but it would be a breaking change to do so, so we keep it for now
+     * @example "textarea" will result in
+     * ```html
+     * <div class="af-form__textarea">
+     *  // ... input
+     * </div>
+     * ```
+     * @default "text"
+     */
+    classNameSuffix?: string;
+    renderInput: (props: {
+        id: string;
+        classModifier: string;
+        errorId?: string;
+        ariaInvalid?: boolean;
+    } & Record<string, unknown>) => ReactNode;
+    /**
+     * Elements to be appended to the end of the input group, just before the 2 ending divs
+     * @example <Field appendChildren={<Button>Submit</Button>} renderinput={() => <span>hello</span>} />
+     * will result in
+     * ```html
+     * <div class="af-form__text">
+     *  <span>hello</span>
+     *  <Button>Submit</Button>
+     * </div>
+     * ```
+     * @optional
+     */
+    appendChildren?: ReactNode;
+};
+export type ConsumerFieldProps = Omit<InputProps, "renderInput" | "classNameSuffix" | "children"> & {
+    /**
+     * Element appended right to the input
+     */
+    children?: ReactNode;
+};
+export declare const Field: ({ classNameContainerInput, classNameContainerLabel, className, label, forceDisplayMessage, message, messageType, required, classModifier, disabled, helpMessage, id, isVisible, roleContainer, ariaLabelContainer, isLabelContainerLinkedToInput, labelPosition, classNameSuffix, renderInput, appendChildren, ...otherProps }: InputProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/distributeur/Form/core/Field.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import classNames from "classnames";
+import { useId } from "react";
+import { FieldError, FormClassManager, HelpMessage, useInputClassModifier, } from ".";
+import { getComponentClassName } from "../../utilities";
+import { useAriaInvalid } from "./useAriaInvalid";
+function isIdDefined(id) {
+    return typeof id === "string" && id.length > 0;
+}
+export const Field = ({ classNameContainerInput = "col-md-10", classNameContainerLabel = "col-md-2", className, label, forceDisplayMessage, message, messageType, required, classModifier = "", disabled = false, helpMessage, id, isVisible = true, roleContainer, ariaLabelContainer, isLabelContainerLinkedToInput = true, labelPosition = "center", classNameSuffix = "text", renderInput, appendChildren, ...otherProps }) => {
+    const inputUseId = useId();
+    const inputId = isIdDefined(id) ? id : inputUseId;
+    const actualRequired = required || classModifier.includes("required");
+    const isInvalid = useAriaInvalid(message, forceDisplayMessage, messageType);
+    const errorId = forceDisplayMessage || helpMessage ? `${inputId}-description` : undefined;
+    const { inputClassModifier, inputFieldClassModifier } = useInputClassModifier(classModifier, disabled, false, actualRequired);
+    const labelId = useId();
+    if (!isVisible) {
+        return null;
+    }
+    const isGroup = roleContainer === "radiogroup" || roleContainer === "group";
+    const LabelElement = isGroup ? "div" : "label";
+    const modifiers = forceDisplayMessage
+        ? `${inputFieldClassModifier} ${FormClassManager.getModifier(messageType)}`
+        : inputFieldClassModifier;
+    const fieldContainerClassName = getComponentClassName(`af-form__${classNameSuffix}`, modifiers);
+    const groupClassName = getComponentClassName(className, classModifier, "af-form__group");
+    return (_jsxs("div", { className: classNames("row", groupClassName, {
+            "af-form__group--required": actualRequired,
+            "af-form__group--label-top": labelPosition === "top",
+        }), role: roleContainer, "aria-invalid": isGroup ? isInvalid : undefined, "aria-required": isGroup ? required : undefined, "aria-label": ariaLabelContainer, "aria-labelledby": isGroup ? labelId : undefined, "aria-errormessage": isGroup && isInvalid ? errorId : undefined, children: [_jsx("div", { className: classNameContainerLabel, children: _jsx(LabelElement, { className: classNames("af-form__group-label", {
+                        "af-form__group-label--required": actualRequired,
+                    }), htmlFor: isLabelContainerLinkedToInput ? inputId : undefined, id: labelId, children: label }) }), _jsxs("div", { className: classNameContainerInput, children: [_jsx("div", { className: fieldContainerClassName, children: renderInput({
+                            classModifier: `${inputClassModifier} ${modifiers}`,
+                            id: inputId,
+                            errorId,
+                            disabled,
+                            ariaInvalid: isInvalid,
+                            required,
+                            ...otherProps,
+                        }) }), forceDisplayMessage ? (_jsx(FieldError, { message: message, messageType: messageType, errorId: errorId })) : (_jsx(HelpMessage, { message: helpMessage, id: errorId })), appendChildren] })] }));
+};

package/dist/distributeur/Form/core/FieldError.d.ts

@@ -0,0 +1,8 @@
+import { MessageTypes } from "./MessageTypes";
+type FieldProps = {
+    message?: string | null;
+    messageType?: MessageTypes;
+    errorId?: string;
+};
+export declare const FieldError: ({ message, messageType, errorId, }: FieldProps) => "" | import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/distributeur/Form/core/FieldError.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { getComponentClassName } from "../../utilities";
+import { MessageTypes } from "./MessageTypes";
+const DEFAULT_CLASS_NAME = "af-form__message";
+export const FieldError = ({ message = null, messageType = MessageTypes.error, errorId = undefined, }) => {
+    const className = getComponentClassName(DEFAULT_CLASS_NAME, messageType, DEFAULT_CLASS_NAME);
+    return (message && (_jsxs("small", { className: className, children: [_jsx("span", { className: "glyphicon glyphicon-exclamation-sign" }), _jsx("span", { id: errorId, role: "alert", className: `af-form__${messageType}-text`, children: message })] })));
+};

package/dist/distributeur/Form/core/FormClassManager.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from "react";
+export declare const FormClassManager: {
+    getFieldInputClassModifier: (modifier: string, disabled: boolean) => string;
+    getInputClassModifier: (modifier: string, children: ReactNode) => string;
+    getModifier: (messageType: string | undefined) => string;
+    getMessageClassModifier: (messageType?: "error" | "success" | "warning", message?: string | null, modifier?: string) => string;
+};

package/dist/distributeur/Form/core/FormClassManager.js

@@ -0,0 +1,36 @@
+import { MessageTypes } from "./MessageTypes";
+const getFieldInputClassModifier = (modifier, disabled) => disabled ? `${modifier} disabled` : modifier;
+const getInputClassModifier = (modifier, children) => children ? `${modifier} hasinfobulle` : modifier;
+const getModifier = (messageType) => {
+    let modifier = "";
+    switch (messageType) {
+        case MessageTypes.success:
+            modifier = "success";
+            break;
+        case MessageTypes.warning:
+            modifier = "warning";
+            break;
+        case MessageTypes.error:
+            modifier = "error";
+            break;
+        default:
+            break;
+    }
+    return modifier;
+};
+const getMessageClassModifier = (messageType, message, modifier) => {
+    if (!message) {
+        return "";
+    }
+    const messageModifier = getModifier(messageType);
+    if (!messageModifier) {
+        return "";
+    }
+    return modifier ? `${modifier} ${messageModifier}` : messageModifier;
+};
+export const FormClassManager = {
+    getFieldInputClassModifier,
+    getInputClassModifier,
+    getModifier,
+    getMessageClassModifier,
+};

package/dist/distributeur/Form/core/HelpMessage.d.ts

@@ -0,0 +1,8 @@
+import { ReactNode } from "react";
+type HelpProps = {
+    message?: ReactNode;
+    isVisible?: boolean;
+    id?: string;
+};
+export declare const HelpMessage: ({ message, isVisible, id }: HelpProps) => false | import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/distributeur/Form/core/HelpMessage.js

@@ -0,0 +1,2 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+export const HelpMessage = ({ message, isVisible = true, id }) => isVisible && (_jsx("small", { id: id, className: "af-form__help", children: message }));

package/dist/distributeur/Form/core/InputList.d.ts

@@ -0,0 +1,8 @@
+export declare const isDisabled: (option: {
+    disabled?: boolean;
+}, disabled: boolean) => boolean;
+export declare const InputList: {
+    isDisabled: (option: {
+        disabled?: boolean;
+    }, disabled: boolean) => boolean;
+};

package/dist/distributeur/Form/core/InputList.js

@@ -0,0 +1,4 @@
+export const isDisabled = (option, disabled) => (option.disabled !== undefined ? option.disabled : disabled);
+export const InputList = {
+    isDisabled,
+};

package/dist/distributeur/Form/core/MessageTypes.d.ts

@@ -0,0 +1,5 @@
+export declare enum MessageTypes {
+    error = "error",
+    success = "success",
+    warning = "warning"
+}

package/dist/distributeur/Form/core/MessageTypes.js

@@ -0,0 +1,6 @@
+export var MessageTypes;
+(function (MessageTypes) {
+    MessageTypes["error"] = "error";
+    MessageTypes["success"] = "success";
+    MessageTypes["warning"] = "warning";
+})(MessageTypes || (MessageTypes = {}));

package/dist/distributeur/Form/core/getFirstId.d.ts

@@ -0,0 +1,2 @@
+import type { Option } from ".";
+export declare const getFirstId: (options: Option[]) => string | undefined;

package/dist/distributeur/Form/core/getFirstId.js

@@ -0,0 +1 @@
+export const getFirstId = (options) => !options || options.length === 0 ? "" : options[0].id;

package/dist/distributeur/Form/core/getOptionClassName.d.ts

@@ -0,0 +1 @@
+export declare function getOptionClassName(className: string, classModifier: string, defaultClassName: string, disabled: boolean): string;

package/dist/distributeur/Form/core/getOptionClassName.js

@@ -0,0 +1,10 @@
+import { getComponentClassName } from "../../utilities";
+export function getOptionClassName(className, classModifier, defaultClassName, disabled) {
+    const classModifierWithDisabled = [
+        classModifier,
+        disabled ? "disabled" : undefined,
+    ]
+        .filter(Boolean)
+        .join(" ");
+    return getComponentClassName(className, classModifierWithDisabled, defaultClassName);
+}