@inseefr/lunatic 2.6.2 → 2.6.3-rc.1

package/lib/src/use-lunatic/commons/fill-components/fill-specific-expression.d.ts

@@ -91,27 +91,9 @@ declare function fillSpecificExpressions(component: DeepTranslateExpression<Luna
         colspan?: number | undefined;
         rowspan?: number | undefined;
     }[];
-    body: {
-        label?: import("../../type-source").LabelType | undefined;
-        value?: string | undefined;
-        format?: string | undefined;
-        dateFormat?: string | undefined;
-        unit?: string | undefined;
-        options: {
-            value: string;
-            label: import("../../type-source").LabelType;
-        }[];
-        response: import("../../type-source").ResponseType;
-        bindingDependencies: string[];
-        componentType?: import("../../type-source").ComponentTypeEnum | undefined;
-        maxLength?: number | undefined;
-        min?: number | undefined;
-        max?: number | undefined;
-        decimals?: number | undefined;
-        colspan?: number | undefined;
-        rowspan?: number | undefined;
-        id?: string | undefined;
-    }[];
+    body: (import("../../type-source").ComponentType | {
+        label: import("../../type-source").LabelType;
+    })[][];
     positioning: "HORIZONTAL";
     value?: Record<string, unknown[]> | undefined;
 } | {
@@ -149,6 +131,7 @@ declare function fillSpecificExpressions(component: DeepTranslateExpression<Luna
     paginatedLoop: boolean;
     value?: Record<string, unknown[]> | undefined;
 } | {
+    getComponents: (x: number, y: number) => import("./fill-components").FilledLunaticComponentProps<"Sequence" | "Subsequence" | "RosterForLoop" | "Loop" | "Table" | "Input" | "InputNumber" | "Datepicker" | "CheckboxGroup" | "CheckboxOne" | "CheckboxBoolean" | "Radio" | "Dropdown" | "Textarea" | "FilterDescription" | "PairwiseLinks" | "Suggester" | "ConfirmationModal" | "ComponentSet" | "Roundabout" | "QuestionExplication">[];
     label: import("react").ReactNode;
     declarations?: import("../../type-source").DeclarationType[] | undefined;
     conditionFilter: import("react").ReactNode;
@@ -169,8 +152,17 @@ declare function fillSpecificExpressions(component: DeepTranslateExpression<Luna
     };
     mandatory?: boolean | undefined;
     page: string;
-    componentType: "Sequence";
+    componentType: "PairwiseLinks";
+    xAxisIterations: import("react").ReactNode;
+    yAxisIterations: import("react").ReactNode;
+    symLinks: {
+        [x: string]: {
+            [x: string]: string;
+        };
+    };
+    components: import("../../type-source").ComponentType[];
 } | {
+    body: unknown[][];
     label: import("react").ReactNode;
     declarations?: import("../../type-source").DeclarationType[] | undefined;
     conditionFilter: import("react").ReactNode;
@@ -191,8 +183,22 @@ declare function fillSpecificExpressions(component: DeepTranslateExpression<Luna
     };
     mandatory?: boolean | undefined;
     page: string;
-    componentType: "Subsequence";
-    gotoPage: string;
+    componentType: "Table";
+    lines: {
+        min: import("react").ReactNode;
+        max: import("react").ReactNode;
+    };
+    header: {
+        value: string;
+        label: string | import("../../type-source").LabelType;
+        options: {
+            value: string;
+            label: import("../../type-source").LabelType;
+        }[];
+        colspan?: number | undefined;
+        rowspan?: number | undefined;
+    }[];
+    positioning: "HORIZONTAL";
 } | {
     label: import("react").ReactNode;
     declarations?: import("../../type-source").DeclarationType[] | undefined;
@@ -214,43 +220,30 @@ declare function fillSpecificExpressions(component: DeepTranslateExpression<Luna
     };
     mandatory?: boolean | undefined;
     page: string;
-    componentType: "Table";
-    lines: {
-        min: import("react").ReactNode;
-        max: import("react").ReactNode;
+    componentType: "Sequence";
+} | {
+    label: import("react").ReactNode;
+    declarations?: import("../../type-source").DeclarationType[] | undefined;
+    conditionFilter: import("react").ReactNode;
+    controls?: import("../../type-source").ControlType[] | undefined;
+    id: string;
+    bindingDependencies?: string[] | undefined;
+    hierarchy: {
+        sequence: {
+            label: import("react").ReactNode;
+            id: string;
+            page: string;
+        };
+        subSequence?: {
+            label: import("react").ReactNode;
+            id: string;
+            page: string;
+        } | undefined;
     };
-    header: {
-        value: string;
-        label: string | import("../../type-source").LabelType;
-        options: {
-            value: string;
-            label: import("../../type-source").LabelType;
-        }[];
-        colspan?: number | undefined;
-        rowspan?: number | undefined;
-    }[];
-    body: {
-        label?: import("../../type-source").LabelType | undefined;
-        value?: string | undefined;
-        format?: string | undefined;
-        dateFormat?: string | undefined;
-        unit?: string | undefined;
-        options: {
-            value: string;
-            label: import("../../type-source").LabelType;
-        }[];
-        response: import("../../type-source").ResponseType;
-        bindingDependencies: string[];
-        componentType?: import("../../type-source").ComponentTypeEnum | undefined;
-        maxLength?: number | undefined;
-        min?: number | undefined;
-        max?: number | undefined;
-        decimals?: number | undefined;
-        colspan?: number | undefined;
-        rowspan?: number | undefined;
-        id?: string | undefined;
-    }[];
-    positioning: "HORIZONTAL";
+    mandatory?: boolean | undefined;
+    page: string;
+    componentType: "Subsequence";
+    gotoPage: string;
 } | {
     label: import("react").ReactNode;
     declarations?: import("../../type-source").DeclarationType[] | undefined;
@@ -450,35 +443,6 @@ declare function fillSpecificExpressions(component: DeepTranslateExpression<Luna
     missingResponse?: {
         name: string;
     } | undefined;
-} | {
-    label: import("react").ReactNode;
-    declarations?: import("../../type-source").DeclarationType[] | undefined;
-    conditionFilter: import("react").ReactNode;
-    controls?: import("../../type-source").ControlType[] | undefined;
-    id: string;
-    bindingDependencies?: string[] | undefined;
-    hierarchy: {
-        sequence: {
-            label: import("react").ReactNode;
-            id: string;
-            page: string;
-        };
-        subSequence?: {
-            label: import("react").ReactNode;
-            id: string;
-            page: string;
-        } | undefined;
-    };
-    mandatory?: boolean | undefined;
-    page: string;
-    componentType: "PairwiseLinks";
-    xAxisIterations: import("react").ReactNode;
-    yAxisIterations: import("react").ReactNode;
-    symLinks: {
-        [x: string]: {
-            [x: string]: string;
-        };
-    };
 } | {
     label: import("react").ReactNode;
     declarations?: import("../../type-source").DeclarationType[] | undefined;

package/lib/src/use-lunatic/commons/get-compatible-vtl-expression.d.ts

@@ -1,6 +1,7 @@
 import type { LunaticExpression } from '../type';
 /**
  * Ensure that an expression is compatible with VTL (convert if necessary)
+ * @deprecated use getExpressionAsString() instead
  */
 declare function getCompatibleVTLExpression(expression: LunaticExpression | string): LunaticExpression | undefined;
 export default getCompatibleVTLExpression;

package/lib/src/use-lunatic/commons/index.d.ts

@@ -1,12 +1,9 @@
 export { default as checkLoops } from './check-loops';
 export { default as createMapPages } from './create-map-pages';
 export { default as executeConditionFilter } from './execute-condition-filter';
-export { default as createExecuteExpression } from './execute-expression';
 export { default as fillComponentExpressions } from './fill-components/fill-component-expressions';
 export { default as getCompatibleVTLExpression } from './get-compatible-vtl-expression';
 export { default as getComponentsFromState } from './get-components-from-state';
-export { default as getErrorsWithoutEmptyValue } from './get-errors-without-empty-value';
 export { default as isFirstLastPage } from './is-First-last-page';
-export { default as isPaginatedLoop } from './is-paginated-loop';
 export { getNewReachedPage, getPageTag, isNewReachedPage } from './page-tag';
 export { default as useComponentsFromState } from './use-components-from-state';

package/lib/src/use-lunatic/commons/variables/behaviours/cleaning-behaviour.d.ts

@@ -0,0 +1,7 @@
+import type { LunaticVariablesStore } from '../lunatic-variables-store';
+import type { LunaticSource } from '../../../type-source';
+/**
+ * Cleaning behaviour for the store
+ * When a variable changes, other variables can be reset
+ */
+export declare function cleaningBehaviour(store: LunaticVariablesStore, cleaning: LunaticSource['cleaning'], initialValues?: Record<string, unknown>): void;

package/lib/src/use-lunatic/commons/variables/behaviours/missing-behaviour.d.ts

@@ -0,0 +1,7 @@
+import type { LunaticVariablesStore } from '../lunatic-variables-store';
+import type { LunaticSource } from '../../../type-source';
+/**
+ * Add missing behaviour to the store
+ * Missing works as a simplified cleaning that reset a linked variable
+ */
+export declare function missingBehaviour(store: LunaticVariablesStore, missing: LunaticSource['missingBlock']): void;

package/lib/src/use-lunatic/commons/variables/behaviours/resizing-behaviour.d.ts

@@ -0,0 +1,7 @@
+import type { LunaticVariablesStore } from '../lunatic-variables-store';
+import type { LunaticSource } from '../../../type-source';
+/**
+ * Resizing behaviour for the store
+ * When a variable changes, multiple other variables can change size (size of the array)
+ */
+export declare function resizingBehaviour(store: LunaticVariablesStore, resizing: LunaticSource['resizing']): void;

package/lib/src/use-lunatic/commons/variables/get-questionnaire-data.d.ts

@@ -0,0 +1,4 @@
+import type { LunaticVariablesStore } from './lunatic-variables-store';
+import type { LunaticSource } from '../../type-source';
+import type { LunaticData } from '../../type';
+export declare function getQuestionnaireData(store: LunaticVariablesStore, variables: LunaticSource['variables'], withCalculated?: boolean, variableNames?: string[]): LunaticData;

package/lib/src/use-lunatic/commons/variables/lunatic-variables-store.d.ts

@@ -0,0 +1,77 @@
+import type { LunaticSource } from '../../type-source';
+import type { LunaticData } from '../../type';
+type IterationLevel = number[];
+type EventArgs = {
+    change: {
+        name: string;
+        value: unknown;
+        iteration?: IterationLevel | undefined;
+    };
+};
+export type LunaticVariablesStoreEvent<T extends keyof EventArgs> = {
+    detail: EventArgs[T];
+};
+export declare class LunaticVariablesStore {
+    private dictionary;
+    private eventTarget;
+    constructor();
+    static makeFromSource(source: LunaticSource, data: LunaticData): LunaticVariablesStore;
+    /**
+     * Retrieve variable value
+     */
+    get<T>(name: string, iteration?: IterationLevel): T | null;
+    /**
+     * Set variable value
+     */
+    set(name: string, value: unknown, args?: Pick<EventArgs['change'], 'iteration'>): LunaticVariable;
+    /**
+     * Register calculated variable
+     */
+    setCalculated(name: string, expression: string, { dependencies, iterationDepth, }?: {
+        dependencies?: string[];
+        iterationDepth?: number;
+    }): LunaticVariable;
+    /**
+     * Run a VTL expression
+     */
+    run(expression: string, args?: {
+        iteration?: IterationLevel;
+        deps?: string[];
+    }): unknown;
+    /**
+     * Bind event listeners
+     */
+    on<T extends keyof EventArgs>(eventName: T, cb: (e: CustomEvent<EventArgs[T]>) => void): void;
+    /**
+     * Detach a listener
+     */
+    off<T extends keyof EventArgs>(eventName: T, cb: (e: CustomEvent<EventArgs[T]>) => void): void;
+    get interpretCount(): number;
+}
+declare class LunaticVariable {
+    updatedAt: Map<string | undefined, number>;
+    private calculatedAt;
+    private value;
+    private dependencies?;
+    private readonly expression?;
+    private readonly dictionary?;
+    private readonly iterationDepth?;
+    private readonly name?;
+    constructor(args?: {
+        expression?: string;
+        dependencies?: string[];
+        dictionary?: Map<string, LunaticVariable>;
+        iterationDepth?: number;
+        name?: string;
+    });
+    getValue(iteration?: IterationLevel): unknown;
+    /**
+     * Set the value and returns true if the variable is touched
+     */
+    setValue(value: unknown, iteration?: IterationLevel): boolean;
+    private getSavedValue;
+    private getDependencies;
+    private getDependenciesValues;
+    private isOutdated;
+}
+export {};

package/lib/src/use-lunatic/reducer/overview/overview-on-init.d.ts

@@ -2,9 +2,8 @@ import type { LunaticOverviewItem, LunaticState } from '../../type';
 import { type ActionInit } from '../../actions';
 export declare function reduceOverviewOnInit(state: LunaticState, action: ActionInit): {
     overview: LunaticOverviewItem[];
-    variables: {
-        [variableName: string]: import("../../type").LunaticStateVariable;
-    };
+    updatedAt: number;
+    variables: import("../../commons/variables/lunatic-variables-store").LunaticVariablesStore;
     pages: {
         [key: string]: {
             components: import("../../type-source").ComponentType[];
@@ -78,14 +77,17 @@ export declare function reduceOverviewOnInit(state: LunaticState, action: Action
     modalErrors?: Record<string, import("../../type").LunaticError[]> | undefined;
     handleChange: (response: {
         name: string;
-    }, value: any, args?: Record<string, unknown> | undefined) => void;
+    }, value: any, args?: {
+        iteration?: number[] | undefined;
+    } | undefined) => void;
     executeExpression: <T extends unknown = unknown>(expression: unknown, args?: {
-        iteration?: number | undefined;
-        linksIterations?: number[] | undefined;
-        logging?: import("../../commons/execute-expression/create-execute-expression").ExpressionLogger | undefined;
+        iteration?: number | number[] | undefined;
         bindingDependencies?: string[] | undefined;
+        deps?: string[] | undefined;
     } | undefined) => T;
-    updateBindings: (variableName: string, value: unknown) => unknown;
+    updateBindings: (variableName: string, value: unknown, options: {
+        iteration?: number[] | undefined;
+    }) => unknown;
     activeControls: boolean;
     shortcut?: boolean | undefined;
     management?: boolean | undefined;

package/lib/src/use-lunatic/reducer/reduce-handle-change.d.ts

@@ -0,0 +1,6 @@
+import { type ActionHandleChange } from '../actions';
+import type { LunaticState } from '../type';
+/**
+ * Update collected variables
+ */
+export declare function reduceHandleChange(state: LunaticState, action: ActionHandleChange): LunaticState;

package/lib/src/use-lunatic/reducer/reduce-on-init.d.ts

@@ -1,15 +1,4 @@
 import { type ActionInit } from '../actions';
-import type { LunaticState, LunaticVariable } from '../type';
-export type VariablesByType = {
-    EXTERNAL: (LunaticVariable & {
-        variableType: 'EXTERNAL';
-    })[];
-    COLLECTED: (LunaticVariable & {
-        variableType: 'COLLECTED';
-    })[];
-    CALCULATED: (LunaticVariable & {
-        variableType: 'CALCULATED';
-    })[];
-};
+import type { LunaticState } from '../type';
 declare const reducers: (acc: LunaticState, action: ActionInit) => LunaticState;
 export default reducers;

package/lib/src/use-lunatic/type-source.d.ts

@@ -117,27 +117,9 @@ export type ComponentRosterForLoopType = {
         colspan?: number;
         rowspan?: number;
     }[];
-    body: {
-        label?: LabelType;
-        value?: string;
-        format?: string;
-        dateFormat?: string;
-        unit?: string;
-        options: {
-            value: string;
-            label: LabelType;
-        }[];
-        response: ResponseType;
-        bindingDependencies: string[];
-        componentType?: ComponentTypeEnum;
-        maxLength?: number;
-        min?: number;
-        max?: number;
-        decimals?: number;
-        colspan?: number;
-        rowspan?: number;
-        id?: string;
-    }[];
+    body: ({
+        label: LabelType;
+    } | ComponentType)[][];
     positioning: 'HORIZONTAL';
 };
 export type ComponentLoopType = {
@@ -217,6 +199,7 @@ export type ComponentPairWiseLinksType = {
     symLinks: {
         [variableName: string]: Record<string, string>;
     };
+    components: ComponentType[];
 };
 export type ComponentComponentSetType = {
     componentType: 'ComponentSet';
@@ -298,6 +281,9 @@ export type LunaticSource = {
         [variableName: string]: {
             size: string;
             variables: string[];
+        } | {
+            sizeForLinksVariables: string[];
+            linksVariables: string[];
         };
     };
 };

package/lib/src/use-lunatic/type.d.ts

@@ -1,7 +1,7 @@
 import type { ReactNode } from 'react';
 import type { ComponentType, ControlType, LunaticSource, Variable } from './type-source';
-import { type ExpressionLogger } from './commons/execute-expression/create-execute-expression';
 import { SuggesterStatus } from './use-suggesters';
+import type { LunaticVariablesStore } from './commons/variables/lunatic-variables-store';
 export type LunaticComponentDefinition<T extends ComponentType['componentType'] = ComponentType['componentType']> = ComponentType & {
     componentType: T;
 };
@@ -9,9 +9,9 @@ export type LunaticControl = ControlType;
 export type VTLBindings = {
     [variableName: string]: unknown;
 };
-export type LunaticData = Partial<Record<Exclude<VariableType, 'COLLECTED'>, Record<string, unknown>> & {
+export type LunaticData = Record<Exclude<VariableType, 'COLLECTED'>, Record<string, unknown>> & {
     COLLECTED: Record<string, LunaticCollectedValue>;
-}>;
+};
 export type LunaticValues = {
     [variableName: string]: unknown;
 };
@@ -59,9 +59,8 @@ export type LunaticStateVariable = {
     };
 }[LunaticVariable['variableType']];
 export type LunaticState = {
-    variables: {
-        [variableName: string]: LunaticStateVariable;
-    };
+    updatedAt: number;
+    variables: LunaticVariablesStore;
     pages: {
         [key: number | string]: {
             components: ComponentType[];
@@ -119,14 +118,17 @@ export type LunaticState = {
     modalErrors?: Record<string, LunaticError[]>;
     handleChange: (response: {
         name: string;
-    }, value: any, args?: Record<string, unknown>) => void;
+    }, value: any, args?: {
+        iteration?: number[];
+    }) => void;
     executeExpression: <T extends unknown = unknown>(expression: unknown, args?: {
-        iteration?: number;
-        linksIterations?: number[];
-        logging?: ExpressionLogger;
+        iteration?: number | number[];
         bindingDependencies?: string[];
+        deps?: string[];
     }) => T;
-    updateBindings: (variableName: string, value: unknown) => unknown;
+    updateBindings: (variableName: string, value: unknown, options: {
+        iteration?: number[];
+    }) => unknown;
     activeControls: boolean;
     shortcut?: boolean;
     management?: boolean;