@inseefr/lunatic 2.3.0 → 2.4.0

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

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

package/lib/src/use-lunatic/commons/is-First-last-page.d.ts

@@ -0,0 +1,6 @@
+import { LunaticState } from '../type';
+declare function isFirstLastPage(pager: LunaticState['pager']): {
+    isFirstPage: boolean;
+    isLastPage: boolean;
+};
+export default isFirstLastPage;

package/lib/src/use-lunatic/commons/is-paginated-loop.d.ts

@@ -0,0 +1,6 @@
+import { LunaticComponentDefinition } from '../type';
+declare function isPaginatedLoop(component: LunaticComponentDefinition): component is LunaticComponentDefinition & {
+    componentType: 'Loop';
+    paginatedLoop: true;
+};
+export default isPaginatedLoop;

package/lib/src/use-lunatic/commons/is-roundabout.d.ts

@@ -0,0 +1,2 @@
+import { LunaticComponentDefinition } from '../type';
+export default function isRoundabout(component: LunaticComponentDefinition): component is LunaticComponentDefinition<'Roundabout'>;

package/lib/src/use-lunatic/commons/page-tag.d.ts

@@ -0,0 +1,12 @@
+import { LunaticState } from '../type';
+/**
+ * Generate page name from the pager
+ */
+export declare function getPageTag(pager: LunaticState['pager']): string;
+export declare function getPagerFromPageTag(pageTag?: string): {
+    page: string;
+    subPage: number;
+    iteration: number;
+} | null;
+export declare function isNewReachedPage(pager: LunaticState['pager']): boolean;
+export declare function getNewReachedPage(pager: LunaticState['pager']): string | undefined;

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

@@ -0,0 +1,4 @@
+import { LunaticState } from '../type';
+import { LunaticComponentProps } from './fill-components/fill-components';
+declare function useComponentsFromState(state: LunaticState): LunaticComponentProps<"CheckboxGroup" | "Sequence" | "Subsequence" | "RosterForLoop" | "Loop" | "Table" | "Input" | "InputNumber" | "Datepicker" | "CheckboxOne" | "CheckboxBoolean" | "Radio" | "Dropdown" | "Textarea" | "FilterDescription" | "PairwiseLinks" | "Roundabout">[];
+export default useComponentsFromState;

package/lib/src/use-lunatic/hooks/use-loop-variables.d.ts

@@ -0,0 +1,5 @@
+import { LunaticState } from '../type';
+/**
+ * Extract the list of variables used for the current loop
+ */
+export declare function useLoopVariables(pager: LunaticState['pager'], pages: LunaticState['pages']): string[];

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

@@ -0,0 +1 @@
+export { default } from './use-lunatic';

package/lib/src/use-lunatic/initial-state.d.ts

@@ -0,0 +1,3 @@
+import type { LunaticState } from './type';
+declare const INITIAL_STATE: LunaticState;
+export default INITIAL_STATE;

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

@@ -0,0 +1,31 @@
+import { FunctionComponent, PropsWithChildren } from 'react';
+/** Provide `missing` `missingStrategy`, `shortcut` and `missingShortcut`, `dontKnowButton`, `refusedButton` to Missing component
+ *  to manage non-response buttons and shortcut */
+export declare const useLunaticMissing: () => {
+    missing: boolean;
+    missingStrategy: () => void;
+    shortcut: boolean;
+    missingShortcut: {
+        dontKnow: string;
+        refused: string;
+    };
+    dontKnowButton: string;
+    refusedButton: string;
+};
+/** Return custom elements list to override native components */
+export declare const useLunaticCustom: () => Record<string, FunctionComponent<unknown>>;
+/** Provide `management` to display data states [COLLECTED,EDITED,FORCED] */
+export declare const useLunaticManagement: () => boolean;
+export declare function createLunaticProvider({ custom, management, missing, missingStrategy, shortcut, missingShortcut, dontKnowButton, refusedButton, }: {
+    custom: Record<string, FunctionComponent<unknown>>;
+    management: boolean;
+    missing: boolean;
+    missingStrategy: () => void;
+    shortcut: boolean;
+    missingShortcut: {
+        dontKnow: string;
+        refused: string;
+    };
+    dontKnowButton: string;
+    refusedButton: string;
+}): FunctionComponent<PropsWithChildren>;

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

@@ -0,0 +1,4 @@
+export { default as isOnEmptyPage } from './is-empty-on-empty-page';
+export { default as resizeArrayVariable } from './resize-array-variable';
+export { isLoopComponent } from './is-loop-component';
+export * from './validate-condition-filter';

package/lib/src/use-lunatic/reducer/commons/is-empty-on-empty-page.d.ts

@@ -0,0 +1,3 @@
+import { LunaticState } from '../../type';
+declare function isOnEmptyPage(state: LunaticState): boolean;
+export default isOnEmptyPage;

package/lib/src/use-lunatic/reducer/commons/is-loop-component.d.ts

@@ -0,0 +1,12 @@
+import { LunaticComponentDefinition } from '../../type';
+export declare const isLoopComponent: (component: LunaticComponentDefinition) => component is (import("../../type-source").ComponentTypeBase & import("../../type-source").ComponentRosterForLoopType & {
+    componentType: "CheckboxGroup" | "Sequence" | "Subsequence" | "RosterForLoop" | "Loop" | "Table" | "Input" | "InputNumber" | "Datepicker" | "CheckboxOne" | "CheckboxBoolean" | "Radio" | "Dropdown" | "Textarea" | "FilterDescription" | "PairwiseLinks" | "Roundabout";
+    errors?: Record<string, import("../../type").LunaticError[]> | undefined;
+} & {
+    componentType: 'Loop' | 'RosterForLoop';
+}) | (import("../../type-source").ComponentTypeBase & import("../../type-source").ComponentLoopType & {
+    componentType: "CheckboxGroup" | "Sequence" | "Subsequence" | "RosterForLoop" | "Loop" | "Table" | "Input" | "InputNumber" | "Datepicker" | "CheckboxOne" | "CheckboxBoolean" | "Radio" | "Dropdown" | "Textarea" | "FilterDescription" | "PairwiseLinks" | "Roundabout";
+    errors?: Record<string, import("../../type").LunaticError[]> | undefined;
+} & {
+    componentType: 'Loop' | 'RosterForLoop';
+});

package/lib/src/use-lunatic/reducer/commons/resize-array-variable.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Cast the variable into an array and adjust the length if necessary
+ */
+declare function resizeArrayVariable<T extends unknown = unknown>(array: unknown, length: number, defaultValue?: T): T[];
+export default resizeArrayVariable;

package/lib/src/use-lunatic/reducer/commons/validate-condition-filter.d.ts

@@ -0,0 +1,6 @@
+import { LunaticState } from '../../type';
+declare function validateLoopConditionFilter(state: LunaticState, { next, iteration }: {
+    next: string;
+    iteration?: number;
+}): boolean;
+export { validateLoopConditionFilter };

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

@@ -0,0 +1 @@
+export { default } from './reducer';

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

@@ -0,0 +1,2 @@
+import { LunaticState } from '../../type';
+export declare const overviewOnChange: (state: LunaticState) => LunaticState;

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

@@ -0,0 +1,99 @@
+import { LunaticOverviewItem, LunaticState } from '../../type';
+import { ActionInit } from '../../actions';
+export declare function reduceOverviewOnInit(state: LunaticState, action: ActionInit): {
+    overview: LunaticOverviewItem[];
+    variables: {
+        [variableName: string]: import("../../type").LunaticStateVariable;
+    };
+    pages: {
+        [key: string]: {
+            components: import("../../type-source").ComponentType[];
+            isLoop: false;
+            iterations?: undefined;
+            loopDependencies?: undefined;
+            subPages?: undefined;
+        } | {
+            components: import("../../type-source").ComponentType[];
+            isLoop: true;
+            iterations: import("../../type").ExpressionType;
+            loopDependencies: string[];
+            subPages: string[];
+        };
+        [key: number]: {
+            components: import("../../type-source").ComponentType[];
+            isLoop: false;
+            iterations?: undefined;
+            loopDependencies?: undefined;
+            subPages?: undefined;
+        } | {
+            components: import("../../type-source").ComponentType[];
+            isLoop: true;
+            iterations: import("../../type").ExpressionType;
+            loopDependencies: string[];
+            subPages: string[];
+        };
+    };
+    isInLoop: boolean;
+    isFirstPage: boolean;
+    isLastPage: boolean;
+    features: "VTL"[];
+    preferences: ["COLLECTED"];
+    savingType: "COLLECTED";
+    cleaning: {
+        [variableName: string]: {
+            [variableName: string]: string;
+        };
+    };
+    missingBlock: {
+        [variable: string]: string[];
+    };
+    resizing: {
+        [variable: string]: {
+            size: string;
+            variables: string[];
+            sizeForLinksVariables?: unknown;
+            linksVariables?: string[] | undefined;
+        };
+    };
+    pager: {
+        lastReachedPage?: string | undefined;
+        maxPage: string;
+        nbSubPages?: number | undefined;
+        page: string;
+        subPage?: number | undefined;
+        iteration?: number | undefined;
+        nbIterations?: number | undefined;
+        shallowIteration?: number | undefined;
+        linksIterations?: number[] | undefined;
+        roundabout?: {
+            page: string;
+        } | undefined;
+    };
+    waiting: boolean;
+    handleChange: (response: {
+        name: string;
+    }, value: unknown, args: Record<string, unknown>) => 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;
+        bindingDependencies?: string[] | undefined;
+    } | undefined) => T;
+    updateBindings: (variableName: string, value: unknown) => unknown;
+    activeControls: boolean;
+    shortcut?: boolean | undefined;
+    management?: boolean | undefined;
+    goToPage: (page: {
+        page: string;
+        iteration?: number | undefined;
+        nbIterations?: number | undefined;
+        subPage?: number | undefined;
+        roundabout?: {
+            page: string;
+        } | undefined;
+    }) => void;
+    getSuggesterStatus: (name: string) => {
+        status: import("../../use-suggesters").SuggesterStatus;
+        timestamp: number;
+    };
+};

package/lib/src/use-lunatic/reducer/reduce-go-next-page.d.ts

@@ -0,0 +1,4 @@
+import { ActionGoNextPage } from '../actions';
+import { LunaticState } from '../type';
+declare const _default: (acc: LunaticState, action: ActionGoNextPage) => LunaticState;
+export default _default;

package/lib/src/use-lunatic/reducer/reduce-go-previous-page.d.ts

@@ -0,0 +1,3 @@
+import { LunaticState } from '../type';
+declare function reduceGoPreviousPage(state: LunaticState): LunaticState;
+export default reduceGoPreviousPage;

package/lib/src/use-lunatic/reducer/reduce-go-to-page.d.ts

@@ -0,0 +1,4 @@
+import { ActionGoToPage } from '../actions';
+import { LunaticState } from '../type';
+declare function reduceGoToPage(state: LunaticState, action: ActionGoToPage): LunaticState;
+export default reduceGoToPage;

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

@@ -0,0 +1 @@
+export { default } from './reduce-handle-change';

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

@@ -0,0 +1,7 @@
+import { LunaticState } from '../../type';
+import { ActionHandleChange } from '../../actions';
+/**
+ * Reset variables to null using the cleaning definition in the source.json
+ */
+declare function reduceCleaning(state: LunaticState, action: ActionHandleChange): LunaticState;
+export default reduceCleaning;

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

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

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

@@ -0,0 +1,4 @@
+import { ActionHandleChange } from '../../actions';
+import { LunaticState } from '../../type';
+declare function reduceHandleChange(state: LunaticState, action: ActionHandleChange): LunaticState;
+export default reduceHandleChange;

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

@@ -0,0 +1,15 @@
+import { LunaticState } from '../../type';
+import { ActionHandleChange } from '../../actions';
+type Payload = ActionHandleChange['payload']['args'] & {
+    name: string;
+    value: string;
+};
+/**
+ * Update the link variable in pair wise situation
+ *
+ * If person1 is "parent" of person2 we have to update person2 as a "child" of person1
+ */
+declare function reduceLinksVariable(variables: LunaticState['variables'], { name, value, linksIterations, symLinks, lengths }: Payload): {
+    [variableName: string]: import("../../type").LunaticStateVariable;
+};
+export default reduceLinksVariable;

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

@@ -0,0 +1,7 @@
+import { LunaticState } from '../../type';
+import { ActionHandleChange } from '../../actions';
+/**
+ * Update value for missing variables
+ */
+declare function reduceMissing(state: LunaticState, action: ActionHandleChange): LunaticState;
+export default reduceMissing;

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

@@ -0,0 +1,4 @@
+import { LunaticState } from '../../type';
+import { ActionHandleChange } from '../../actions';
+declare function reduceResizing(state: LunaticState, action: ActionHandleChange): LunaticState;
+export default reduceResizing;

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

@@ -0,0 +1,14 @@
+import { LunaticState } from '../../type';
+type Args = {
+    name: string;
+    value: unknown;
+    index: number;
+    length: number;
+};
+/**
+ * Inject the value at a specific index (and resize the value if necessary)
+ */
+declare function reduceVariablesArray(variables: LunaticState['variables'], args: Args): {
+    [variableName: string]: import("../../type").LunaticStateVariable;
+};
+export default reduceVariablesArray;

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

@@ -0,0 +1,9 @@
+import { LunaticState } from '../../type';
+/**
+ * Add the value for the variable in the corresponding variable object
+ */
+declare function reduceVariablesSimple(variables: LunaticState['variables'], { name, value }: {
+    name: string;
+    value: unknown;
+}): LunaticState['variables'];
+export default reduceVariablesSimple;

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

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

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

@@ -0,0 +1,4 @@
+import { LunaticState } from '../type';
+import { ActionOnSetWaiting } from '../actions';
+declare function reduceOnSetWaiting(state: LunaticState, action: ActionOnSetWaiting): LunaticState;
+export default reduceOnSetWaiting;

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

@@ -0,0 +1,99 @@
+import type { LunaticState } from '../type';
+export declare function reduceToRoundabout(state: LunaticState): LunaticState | {
+    isInLoop: boolean;
+    pager: {
+        page: string;
+        lastReachedPage?: string | undefined;
+        maxPage: string;
+        nbSubPages?: number | undefined;
+        subPage?: number | undefined;
+        iteration?: number | undefined;
+        nbIterations?: number | undefined;
+        shallowIteration?: number | undefined;
+        linksIterations?: number[] | undefined;
+        roundabout?: {
+            page: string;
+        } | undefined;
+    };
+    modalErrors: undefined;
+    variables: {
+        [variableName: string]: import("../type").LunaticStateVariable;
+    };
+    pages: {
+        [key: string]: {
+            components: import("../type-source").ComponentType[];
+            isLoop: false;
+            iterations?: undefined;
+            loopDependencies?: undefined;
+            subPages?: undefined;
+        } | {
+            components: import("../type-source").ComponentType[];
+            isLoop: true;
+            iterations: import("../type").ExpressionType;
+            loopDependencies: string[];
+            subPages: string[];
+        };
+        [key: number]: {
+            components: import("../type-source").ComponentType[];
+            isLoop: false;
+            iterations?: undefined;
+            loopDependencies?: undefined;
+            subPages?: undefined;
+        } | {
+            components: import("../type-source").ComponentType[];
+            isLoop: true;
+            iterations: import("../type").ExpressionType;
+            loopDependencies: string[];
+            subPages: string[];
+        };
+    };
+    isFirstPage: boolean;
+    isLastPage: boolean;
+    features: "VTL"[];
+    preferences: ["COLLECTED"];
+    savingType: "COLLECTED";
+    cleaning: {
+        [variableName: string]: {
+            [variableName: string]: string;
+        };
+    };
+    missingBlock: {
+        [variable: string]: string[];
+    };
+    resizing: {
+        [variable: string]: {
+            size: string;
+            variables: string[];
+            sizeForLinksVariables?: unknown;
+            linksVariables?: string[] | undefined;
+        };
+    };
+    overview: import("../type").LunaticOverviewItem[];
+    waiting: boolean;
+    handleChange: (response: {
+        name: string;
+    }, value: unknown, args: Record<string, unknown>) => 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;
+        bindingDependencies?: string[] | undefined;
+    } | undefined) => T;
+    updateBindings: (variableName: string, value: unknown) => unknown;
+    activeControls: boolean;
+    shortcut?: boolean | undefined;
+    management?: boolean | undefined;
+    goToPage: (page: {
+        page: string;
+        iteration?: number | undefined;
+        nbIterations?: number | undefined;
+        subPage?: number | undefined;
+        roundabout?: {
+            page: string;
+        } | undefined;
+    }) => void;
+    getSuggesterStatus: (name: string) => {
+        status: import("../use-suggesters").SuggesterStatus;
+        timestamp: number;
+    };
+};

package/lib/src/use-lunatic/reducer/reduce-update-state.d.ts

@@ -0,0 +1,3 @@
+import { ActionUpdateState } from '../actions';
+import { LunaticState } from '../type';
+export declare function reduceUpdateState(state: LunaticState, action: ActionUpdateState): LunaticState;

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

@@ -0,0 +1,4 @@
+import { Action } from '../actions';
+import { LunaticState } from '../type';
+declare function reducer(state: LunaticState, action: Action): LunaticState;
+export default reducer;

package/lib/src/use-lunatic/reducer/validate-controls/validation-utils.d.ts

@@ -0,0 +1,6 @@
+import { StateForControls } from '../../commons/compile-controls';
+import { LunaticControl, LunaticError } from '../../type';
+/**
+ * Convert controls into errors
+ */
+export declare function resolveComponentControls(state: StateForControls, controls: LunaticControl[]): LunaticError[];