@inseefr/lunatic 2.4.2-beta → 2.4.3-beta

package/lib/src/components/textarea/lunatic-textarea.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import PropTypes from 'prop-types';
+import { LunaticComponentProps } from '../type';
+declare const LunaticTextarea: {
+    (props: LunaticComponentProps<'Textarea'>): JSX.Element;
+    defaultProps: {
+        rows: number;
+        maxLength: number;
+        cols: number;
+        placeholder: string;
+    };
+    propTypes: {
+        rows: PropTypes.Requireable<number>;
+        maxLength: PropTypes.Requireable<number>;
+        cols: PropTypes.Requireable<number>;
+        placeholder: PropTypes.Requireable<string>;
+    };
+};
+export default LunaticTextarea;

package/lib/src/components/type.d.ts

@@ -1,22 +1,29 @@
-import { CSSProperties, FunctionComponent, ReactNode } from 'react';
 import { LunaticComponentDefinition, LunaticError, LunaticExpression, LunaticState } from '../use-lunatic/type';
-type SharedProps<ValueType> = {
+import { CSSProperties, FunctionComponent, ReactNode } from 'react';
+import { SuggesterStatus } from '../use-lunatic/use-suggesters';
+import useLunatic from '../use-lunatic';
+export type LunaticBaseProps<ValueType = unknown> = {
     id: string;
     handleChange: (response: {
         name: string;
-    }, value: ValueType, args: Record<string, unknown>) => void;
-    errors?: Record<string, LunaticError[]>;
-    preferences: LunaticState['preferences'];
+    }, value: ValueType, args?: Record<string, unknown>) => void;
+    errors?: {
+        [id: string]: LunaticError[];
+    };
+    preferences?: LunaticState['preferences'];
     declarations?: {
         id: string;
         declarationType: string;
         position: string;
         label: ReactNode;
     }[];
-    label: ReactNode;
+    label?: ReactNode;
     disabled?: boolean;
     missing?: unknown;
-    missingResponse?: unknown;
+    missingResponse?: {
+        name: string;
+        value?: unknown;
+    };
     management?: LunaticState['management'];
     description?: ReactNode;
     shortcut?: boolean;
@@ -25,11 +32,17 @@ type SharedProps<ValueType> = {
     readOnly?: boolean;
     className?: string;
     style?: CSSProperties;
+    iteration?: number;
+    executeExpression: LunaticState['executeExpression'];
+    features?: string[];
+    componentType?: string;
 };
-type SuggesterOption = {
+export type SuggesterOption = {
     children?: string[];
-    id: string;
-    label: string;
+    id?: string;
+    description?: ReactNode;
+    label?: ReactNode;
+    value: string;
     niveau?: string;
     parent?: string;
     tokensMap?: Record<string, {
@@ -38,7 +51,7 @@ type SuggesterOption = {
     }>;
 };
 type ComponentPropsByType = {
-    InputNumber: SharedProps<number> & {
+    InputNumber: LunaticBaseProps<number | null> & {
         min: number;
         max: number;
         decimals: number;
@@ -47,16 +60,20 @@ type ComponentPropsByType = {
             name: string;
         };
     };
-    Input: SharedProps<string> & {
+    Input: LunaticBaseProps<string> & {
         maxLength?: number;
         value: null | string;
         response: {
             name: string;
         };
     };
-    Sequence: Pick<SharedProps<string>, 'id' | 'declarations' | 'label' | 'style'>;
-    Subsequence: Pick<SharedProps<string>, 'id' | 'declarations' | 'label'>;
-    RosterForLoop: SharedProps<unknown> & {
+    Sequence: Pick<LunaticBaseProps<string>, 'id' | 'declarations' | 'label' | 'style'>;
+    Subsequence: Pick<LunaticBaseProps<string>, 'id' | 'declarations' | 'label'>;
+    ComponentSet: LunaticBaseProps<unknown> & {
+        components: LunaticComponentDefinition[];
+        value: Record<string, unknown>;
+    };
+    RosterForLoop: LunaticBaseProps<unknown> & {
         lines: {
             min: number;
             max: number;
@@ -65,13 +82,12 @@ type ComponentPropsByType = {
         components: LunaticComponentDefinition[];
         executeExpression: LunaticState['executeExpression'];
         value: Record<string, unknown[]>;
-        componentType: 'RosterForLoop';
         headers?: Array<{
-            label: LunaticExpression;
+            label: ReactNode;
         }>;
         paginatedLoop?: boolean;
     };
-    Loop: SharedProps<unknown> & {
+    Loop: LunaticBaseProps<unknown> & {
         lines: {
             min: number;
             max: number;
@@ -80,15 +96,17 @@ type ComponentPropsByType = {
         components: LunaticComponentDefinition[];
         executeExpression: LunaticState['executeExpression'];
         value: Record<string, unknown[]>;
-        componentType: 'Loop';
         headers?: Array<{
-            label: LunaticExpression;
+            label: ReactNode;
         }>;
         paginatedLoop?: boolean;
     };
-    Table: SharedProps<unknown> & {
+    Table: LunaticBaseProps<unknown> & {
+        value: Record<string, unknown>;
         header: Array<{
-            label: LunaticExpression;
+            label: ReactNode;
+            rowspan?: number;
+            colspan?: number;
         }>;
         body: Array<Array<{
             label: LunaticExpression;
@@ -96,24 +114,27 @@ type ComponentPropsByType = {
         executeExpression: LunaticState['executeExpression'];
         iteration: LunaticState['pager']['iteration'];
     };
-    Datepicker: SharedProps<string> & {
+    Datepicker: LunaticBaseProps<string | null> & {
         min?: string;
         max?: string;
-        value: null | string;
         response: {
             name: string;
         };
     };
-    CheckboxGroup: SharedProps<Record<string, boolean | null>> & {
+    CheckboxGroup: LunaticBaseProps<Record<string, boolean | null>> & {
         responses: Array<{
             id: string;
             label: ReactNode;
+            description?: ReactNode;
             response: {
                 name: string;
             };
         }>;
+        handleChange: (response: {
+            name: string;
+        }, value: boolean, args?: Record<string, unknown>) => void;
     };
-    CheckboxOne: SharedProps<string> & {
+    CheckboxOne: LunaticBaseProps<string | null> & {
         options: Array<{
             description: ReactNode;
             label: ReactNode;
@@ -123,7 +144,16 @@ type ComponentPropsByType = {
             name: string;
         };
     };
-    CheckboxBoolean: SharedProps<string> & {
+    Switch: LunaticBaseProps<boolean> & {
+        response: {
+            name: string;
+        };
+        statusLabel?: {
+            true: string;
+            false: string;
+        };
+    };
+    CheckboxBoolean: LunaticBaseProps<boolean> & {
         options: Array<{
             description: ReactNode;
             label: ReactNode;
@@ -133,7 +163,7 @@ type ComponentPropsByType = {
             name: string;
         };
     };
-    Radio: SharedProps<string> & {
+    Radio: LunaticBaseProps<string | null> & {
         options: Array<{
             description: ReactNode;
             label: ReactNode;
@@ -144,7 +174,19 @@ type ComponentPropsByType = {
             name: string;
         };
     };
-    Dropdown: SharedProps<string> & {
+    Roundabout: LunaticBaseProps<string> & {
+        iterations: number;
+        goToPage: ReturnType<typeof useLunatic>['goToPage'];
+        page: string;
+        locked?: boolean;
+        expressions: {
+            unnecessary?: Array<boolean>;
+            complete?: Array<boolean>;
+            partial?: Array<boolean>;
+            label?: Array<string>;
+        };
+    };
+    Dropdown: LunaticBaseProps<string | null> & {
         options: Array<{
             description: ReactNode;
             label: ReactNode;
@@ -153,17 +195,19 @@ type ComponentPropsByType = {
         response: {
             name: string;
         };
+        writable?: boolean;
     };
-    Textarea: SharedProps<string> & {
+    Textarea: LunaticBaseProps<string> & {
         cols?: number;
+        placeHolder?: string;
         maxLength?: number;
         rows?: number;
         response: {
             name: string;
         };
     };
-    FilterDescription: Pick<SharedProps<string>, 'id' | 'label'>;
-    PairwiseLinks: SharedProps<string> & {
+    FilterDescription: Pick<LunaticBaseProps<string>, 'id' | 'label'>;
+    PairwiseLinks: Omit<LunaticBaseProps, 'value'> & {
         components: LunaticComponentDefinition[];
         features?: LunaticState['features'];
         executeExpression: LunaticState['executeExpression'];
@@ -172,15 +216,19 @@ type ComponentPropsByType = {
         symLinks: Record<string, Record<string, string>>;
         value: Record<string, unknown[]>;
     };
-    Suggester: SharedProps<string> & {
+    Suggester: LunaticBaseProps<string | null> & {
         storeName: string;
-        optionRendered: FunctionComponent<{
+        getSuggesterStatus: (name: string) => {
+            status: SuggesterStatus;
+            timestamp: number;
+        };
+        optionRenderer: FunctionComponent<{
             option: SuggesterOption;
             placeholder?: string;
             search?: string;
         }>;
         labelRenderer: FunctionComponent<{
-            option: SuggesterOption;
+            option?: SuggesterOption;
             selected?: boolean;
             search?: string;
         }>;
@@ -191,5 +239,6 @@ type ComponentPropsByType = {
         };
     };
 };
-export type ComponentProps<T extends keyof ComponentPropsByType> = ComponentPropsByType[T];
+export type LunaticComponentType = keyof ComponentPropsByType;
+export type LunaticComponentProps<T extends LunaticComponentType = LunaticComponentType> = ComponentPropsByType[T];
 export {};

package/lib/src/hooks/use-ref-sync.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+/**
+ * useRef, but keep the value in sync on every render
+ */
+export declare function useRefSync<T extends unknown>(value: T): import("react").MutableRefObject<T>;

package/lib/src/i18n/dictionary.d.ts

@@ -23,6 +23,10 @@ declare const dictionary: {
         readonly fr: "Refus";
         readonly en: "Refused";
     };
+    readonly PLACEHOLDER: {
+        readonly fr: "Commencez votre saisie...";
+        readonly en: "Start typing...";
+    };
 };
 export default dictionary;
 export type Dictionary = typeof dictionary;

package/lib/src/i18n/index.d.ts

@@ -3,5 +3,5 @@ export declare const inputNumberPropsI18N: {
     thousandSeparator: string;
     decimalSeparator: string;
 };
-declare const _default: Record<"DK" | "RF" | "DEFAULT_BUTTON_ADD" | "DEFAULT_BUTTON_REMOVE" | "MODAL_IGNORE" | "MODAL_CORRECT", string>;
+declare const _default: Record<"DK" | "RF" | "DEFAULT_BUTTON_ADD" | "DEFAULT_BUTTON_REMOVE" | "MODAL_IGNORE" | "MODAL_CORRECT" | "PLACEHOLDER", string>;
 export default _default;

package/lib/src/index.d.ts

@@ -1,3 +1,4 @@
 export * from './components';
 export { default as useLunatic } from './use-lunatic';
 export type { LunaticComponentDefinition, LunaticControl, LunaticData, LunaticValues, LunaticError, LunaticExpression, LunaticVariable, LunaticCollectedValue, LunaticStateVariable, LunaticState, } from './use-lunatic/type';
+export type { LunaticComponentProps } from './components/type';

package/lib/src/type.utils.d.ts

@@ -1 +1,5 @@
 export type Overwrite<T, U> = Omit<T, keyof U> & U;
+type Defined<T> = T extends undefined | infer V ? V : T;
+export type ItemOf<ArrayType> = Defined<ArrayType> extends (infer ElementType)[] ? ElementType : never;
+export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+export {};

package/lib/src/use-lunatic/commons/execute-expression/create-refresh-calculated.d.ts

@@ -16,9 +16,9 @@ type Args = {
  */
 declare function createRefreshCalculated({ variables, execute, bindings }: Args): readonly [(map: {
     [variableName: string]: unknown;
-}, { rootExpression, iteration, linksIterations, }: {
+}, { rootExpression, iteration, linksIterations, }?: {
     rootExpression?: string | undefined;
     iteration?: number | undefined;
     linksIterations?: number[] | undefined;
-}) => {}, (name: string, variable: LunaticVariable) => void];
+}) => Record<string, unknown>, (name: string, variable: LunaticVariable) => void];
 export default createRefreshCalculated;

package/lib/src/use-lunatic/commons/execute-expression/create-refresh-calculated.spec.d.ts

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

package/lib/src/use-lunatic/commons/fill-components/fill-component-expressions.d.ts

@@ -5,5 +5,8 @@ export type DeepTranslateExpression<T> = T extends LunaticExpression ? ReactNode
 } ? {
     [key in keyof T]: DeepTranslateExpression<T[key]>;
 } : T;
-declare function fillComponentExpressions(component: LunaticComponentDefinition, state: Pick<LunaticState, 'pager' | 'executeExpression'>): LunaticComponentDefinition<"CheckboxGroup" | "Sequence" | "Subsequence" | "RosterForLoop" | "Loop" | "Table" | "Input" | "InputNumber" | "Datepicker" | "CheckboxOne" | "CheckboxBoolean" | "Radio" | "Dropdown" | "Textarea" | "FilterDescription" | "PairwiseLinks" | "Roundabout">;
+declare function fillComponentExpressions(component: LunaticComponentDefinition, state: {
+    executeExpression: LunaticState['executeExpression'];
+    pager: Pick<LunaticState['pager'], 'iteration' | 'linksIterations'>;
+}): LunaticComponentDefinition;
 export default fillComponentExpressions;

package/lib/src/use-lunatic/commons/fill-components/fill-from-state.d.ts

@@ -9,7 +9,7 @@ export type FilledProps = {
 declare function fillFromState(component: LunaticComponentDefinition, state: LunaticState): {
     handleChange: (response: {
         name: string;
-    }, value: unknown, args: Record<string, unknown>) => void;
+    }, value: any, args?: Record<string, unknown> | undefined) => void;
     executeExpression: <T extends unknown = unknown>(expression: unknown, args?: {
         iteration?: number | undefined;
         linksIterations?: number[] | undefined;
@@ -43,11 +43,10 @@ declare function fillFromState(component: LunaticComponentDefinition, state: Lun
     mandatory?: boolean | undefined;
     page: string;
     componentType: "Sequence";
-    errors?: Record<string, import("../../type").LunaticError[]> | undefined;
 } | {
     handleChange: (response: {
         name: string;
-    }, value: unknown, args: Record<string, unknown>) => void;
+    }, value: any, args?: Record<string, unknown> | undefined) => void;
     executeExpression: <T extends unknown = unknown>(expression: unknown, args?: {
         iteration?: number | undefined;
         linksIterations?: number[] | undefined;
@@ -82,11 +81,10 @@ declare function fillFromState(component: LunaticComponentDefinition, state: Lun
     page: string;
     componentType: "Subsequence";
     gotoPage: string;
-    errors?: Record<string, import("../../type").LunaticError[]> | undefined;
 } | {
     handleChange: (response: {
         name: string;
-    }, value: unknown, args: Record<string, unknown>) => void;
+    }, value: any, args?: Record<string, unknown> | undefined) => void;
     executeExpression: <T extends unknown = unknown>(expression: unknown, args?: {
         iteration?: number | undefined;
         linksIterations?: number[] | undefined;
@@ -157,11 +155,10 @@ declare function fillFromState(component: LunaticComponentDefinition, state: Lun
         id?: string | undefined;
     }[];
     positioning: "HORIZONTAL";
-    errors?: Record<string, import("../../type").LunaticError[]> | undefined;
 } | {
     handleChange: (response: {
         name: string;
-    }, value: unknown, args: Record<string, unknown>) => void;
+    }, value: any, args?: Record<string, unknown> | undefined) => void;
     executeExpression: <T extends unknown = unknown>(expression: unknown, args?: {
         iteration?: number | undefined;
         linksIterations?: number[] | undefined;
@@ -205,11 +202,10 @@ declare function fillFromState(component: LunaticComponentDefinition, state: Lun
     maxPage: string;
     depth: number;
     paginatedLoop: boolean;
-    errors?: Record<string, import("../../type").LunaticError[]> | undefined;
 } | {
     handleChange: (response: {
         name: string;
-    }, value: unknown, args: Record<string, unknown>) => void;
+    }, value: any, args?: Record<string, unknown> | undefined) => void;
     executeExpression: <T extends unknown = unknown>(expression: unknown, args?: {
         iteration?: number | undefined;
         linksIterations?: number[] | undefined;
@@ -279,11 +275,10 @@ declare function fillFromState(component: LunaticComponentDefinition, state: Lun
         id?: string | undefined;
     }[];
     positioning: "HORIZONTAL";
-    errors?: Record<string, import("../../type").LunaticError[]> | undefined;
 } | {
     handleChange: (response: {
         name: string;
-    }, value: unknown, args: Record<string, unknown>) => void;
+    }, value: any, args?: Record<string, unknown> | undefined) => void;
     executeExpression: <T extends unknown = unknown>(expression: unknown, args?: {
         iteration?: number | undefined;
         linksIterations?: number[] | undefined;
@@ -322,11 +317,10 @@ declare function fillFromState(component: LunaticComponentDefinition, state: Lun
     min?: number | undefined;
     max?: number | undefined;
     decimals?: number | undefined;
-    errors?: Record<string, import("../../type").LunaticError[]> | undefined;
 } | {
     handleChange: (response: {
         name: string;
-    }, value: unknown, args: Record<string, unknown>) => void;
+    }, value: any, args?: Record<string, unknown> | undefined) => void;
     executeExpression: <T extends unknown = unknown>(expression: unknown, args?: {
         iteration?: number | undefined;
         linksIterations?: number[] | undefined;
@@ -364,11 +358,10 @@ declare function fillFromState(component: LunaticComponentDefinition, state: Lun
     response: import("../../type-source").ResponseType;
     min?: string | undefined;
     max?: string | undefined;
-    errors?: Record<string, import("../../type").LunaticError[]> | undefined;
 } | {
     handleChange: (response: {
         name: string;
-    }, value: unknown, args: Record<string, unknown>) => void;
+    }, value: any, args?: Record<string, unknown> | undefined) => void;
     executeExpression: <T extends unknown = unknown>(expression: unknown, args?: {
         iteration?: number | undefined;
         linksIterations?: number[] | undefined;
@@ -407,11 +400,10 @@ declare function fillFromState(component: LunaticComponentDefinition, state: Lun
         response: import("../../type-source").ResponseType;
         id: string;
     }[];
-    errors?: Record<string, import("../../type").LunaticError[]> | undefined;
 } | {
     handleChange: (response: {
         name: string;
-    }, value: unknown, args: Record<string, unknown>) => void;
+    }, value: any, args?: Record<string, unknown> | undefined) => void;
     executeExpression: <T extends unknown = unknown>(expression: unknown, args?: {
         iteration?: number | undefined;
         linksIterations?: number[] | undefined;
@@ -446,11 +438,10 @@ declare function fillFromState(component: LunaticComponentDefinition, state: Lun
     page: string;
     componentType: "CheckboxBoolean";
     response: import("../../type-source").ResponseType;
-    errors?: Record<string, import("../../type").LunaticError[]> | undefined;
 } | {
     handleChange: (response: {
         name: string;
-    }, value: unknown, args: Record<string, unknown>) => void;
+    }, value: any, args?: Record<string, unknown> | undefined) => void;
     executeExpression: <T extends unknown = unknown>(expression: unknown, args?: {
         iteration?: number | undefined;
         linksIterations?: number[] | undefined;
@@ -489,11 +480,10 @@ declare function fillFromState(component: LunaticComponentDefinition, state: Lun
         label: import("../../type-source").LabelType;
     }[];
     response: import("../../type-source").ResponseType;
-    errors?: Record<string, import("../../type").LunaticError[]> | undefined;
 } | {
     handleChange: (response: {
         name: string;
-    }, value: unknown, args: Record<string, unknown>) => void;
+    }, value: any, args?: Record<string, unknown> | undefined) => void;
     executeExpression: <T extends unknown = unknown>(expression: unknown, args?: {
         iteration?: number | undefined;
         linksIterations?: number[] | undefined;
@@ -528,11 +518,10 @@ declare function fillFromState(component: LunaticComponentDefinition, state: Lun
     page: string;
     componentType: "FilterDescription";
     filterDescription: boolean;
-    errors?: Record<string, import("../../type").LunaticError[]> | undefined;
 } | {
     handleChange: (response: {
         name: string;
-    }, value: unknown, args: Record<string, unknown>) => void;
+    }, value: any, args?: Record<string, unknown> | undefined) => void;
     executeExpression: <T extends unknown = unknown>(expression: unknown, args?: {
         iteration?: number | undefined;
         linksIterations?: number[] | undefined;
@@ -571,11 +560,10 @@ declare function fillFromState(component: LunaticComponentDefinition, state: Lun
         label: import("../../type-source").LabelType;
     }[];
     response: import("../../type-source").ResponseType;
-    errors?: Record<string, import("../../type").LunaticError[]> | undefined;
 } | {
     handleChange: (response: {
         name: string;
-    }, value: unknown, args: Record<string, unknown>) => void;
+    }, value: any, args?: Record<string, unknown> | undefined) => void;
     executeExpression: <T extends unknown = unknown>(expression: unknown, args?: {
         iteration?: number | undefined;
         linksIterations?: number[] | undefined;
@@ -614,11 +602,10 @@ declare function fillFromState(component: LunaticComponentDefinition, state: Lun
     symLinks: {
         [variableName: string]: Record<string, string>;
     };
-    errors?: Record<string, import("../../type").LunaticError[]> | undefined;
 } | {
     handleChange: (response: {
         name: string;
-    }, value: unknown, args: Record<string, unknown>) => void;
+    }, value: any, args?: Record<string, unknown> | undefined) => void;
     executeExpression: <T extends unknown = unknown>(expression: unknown, args?: {
         iteration?: number | undefined;
         linksIterations?: number[] | undefined;
@@ -656,11 +643,10 @@ declare function fillFromState(component: LunaticComponentDefinition, state: Lun
     iterations: import("../../type-source").LabelType;
     locked: boolean;
     expressions: Record<string, import("../../type-source").LabelType>;
-    errors?: Record<string, import("../../type").LunaticError[]> | undefined;
 } | {
     handleChange: (response: {
         name: string;
-    }, value: unknown, args: Record<string, unknown>) => void;
+    }, value: any, args?: Record<string, unknown> | undefined) => void;
     executeExpression: <T extends unknown = unknown>(expression: unknown, args?: {
         iteration?: number | undefined;
         linksIterations?: number[] | undefined;
@@ -694,6 +680,43 @@ declare function fillFromState(component: LunaticComponentDefinition, state: Lun
     mandatory?: boolean | undefined;
     page: string;
     componentType: "Input" | "CheckboxOne" | "Textarea";
-    errors?: Record<string, import("../../type").LunaticError[]> | undefined;
+} | {
+    handleChange: (response: {
+        name: string;
+    }, value: any, args?: Record<string, unknown> | undefined) => void;
+    executeExpression: <T extends unknown = unknown>(expression: unknown, args?: {
+        iteration?: number | undefined;
+        linksIterations?: number[] | undefined;
+        logging?: import("../execute-expression/create-execute-expression").ExpressionLogger | undefined;
+        bindingDependencies?: string[] | undefined;
+    } | undefined) => T;
+    preferences: ["COLLECTED"];
+    goToPage: (page: {
+        page: string;
+        iteration?: number | undefined;
+        nbIterations?: number | undefined;
+        subPage?: number | undefined;
+        roundabout?: {
+            page: string;
+        } | undefined;
+    }) => void;
+    shortcut: boolean | undefined;
+    getSuggesterStatus: (name: string) => {
+        status: import("../../use-suggesters").SuggesterStatus;
+        timestamp: number;
+    };
+    label: import("../../type-source").LabelType;
+    declarations: import("../../type-source").DeclarationType[];
+    conditionFilter: import("../../type-source").ConditionFilterType;
+    controls?: import("../../type-source").ControlType[] | undefined;
+    id: string;
+    storeName: string;
+    bindingDependencies: string[];
+    hierarchy: import("../../type-source").Hierarchy;
+    missingResponse: import("../../type-source").ResponseType;
+    mandatory?: boolean | undefined;
+    page: string;
+    componentType: "ComponentSet";
+    components: import("../../type-source").ComponentType[];
 };
 export default fillFromState;