@inseefr/lunatic 2.3.1 → 2.4.1

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

@@ -0,0 +1,5 @@
+export * from './component-types';
+export * from './declarations';
+export * from './value-types';
+export * from './variable-types';
+export * from './event-types';

package/lib/src/constants/supported-preferences.d.ts

@@ -0,0 +1 @@
+export declare const supportedPreferences: string[];

package/lib/src/constants/value-types.d.ts

@@ -0,0 +1,5 @@
+export declare const PREVIOUS = "PREVIOUS";
+export declare const COLLECTED = "COLLECTED";
+export declare const FORCED = "FORCED";
+export declare const EDITED = "EDITED";
+export declare const INPUTED = "INPUTED";

package/lib/src/constants/variable-types.d.ts

@@ -0,0 +1,2 @@
+export declare const EXTERNAL: "EXTERNAL";
+export declare const CALCULATED: "CALCULATED";

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

@@ -0,0 +1,24 @@
+import { AbstractDictionary, DictionaryLang } from './dictionary';
+/**
+ * Based on the locale passed as a paremeter, this function will return
+ * the corresponding dictionary.
+ *
+ * @param {string} lang the lang of the user
+ * @param {any} dict
+ */
+declare function createDictionary<T>(lang: DictionaryLang, dict: AbstractDictionary<T>): Record<keyof T, string>;
+export default createDictionary;
+/**
+ * This function will return only the lang part of a locale
+ * For example, with fr-FR, will return fr
+ * If the lang is not fr, will return en
+ * @param {string} lang the lang of the user
+ */
+export declare const supportedLanguages: DictionaryLang[];
+/**
+ * Return the current lang based of the settings of the browser
+ *
+ * @param {String=} defaultLang
+ * @returns {String}
+ */
+export declare const getLang: () => DictionaryLang;

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

@@ -0,0 +1,37 @@
+declare const dictionary: {
+    readonly DEFAULT_BUTTON_ADD: {
+        readonly fr: "Ajouter une ligne";
+        readonly en: "Add row";
+    };
+    readonly DEFAULT_BUTTON_REMOVE: {
+        readonly fr: "Supprimer une ligne";
+        readonly en: "Remove row";
+    };
+    readonly MODAL_IGNORE: {
+        readonly fr: "Poursuivre";
+        readonly en: "Ignore";
+    };
+    readonly MODAL_CORRECT: {
+        readonly fr: "Corriger ma réponse";
+        readonly en: "Correct";
+    };
+    readonly DK: {
+        readonly fr: "Ne sais pas";
+        readonly en: "Don't know";
+    };
+    readonly RF: {
+        readonly fr: "Refus";
+        readonly en: "Refused";
+    };
+};
+export default dictionary;
+export type Dictionary = typeof dictionary;
+export type DictionaryLang = 'fr' | 'en';
+export type Entries<T> = {
+    [K in keyof T]: [K, T[K]];
+}[keyof T][];
+export type AbstractDictionary<T> = {
+    [Key in keyof T]: {
+        [Lang in DictionaryLang]: string;
+    };
+};

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

@@ -0,0 +1,7 @@
+export declare const inputNumberPropsI18N: {
+    allDecimalSeparators: ("." | ",")[];
+    thousandSeparator: string;
+    decimalSeparator: string;
+};
+declare const _default: Record<"DK" | "RF" | "DEFAULT_BUTTON_ADD" | "DEFAULT_BUTTON_REMOVE" | "MODAL_IGNORE" | "MODAL_CORRECT", string>;
+export default _default;

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

@@ -0,0 +1,13 @@
+declare const inputNumberProps: {
+    readonly thousandSeparator: {
+        readonly fr: " ";
+        readonly en: ",";
+    };
+    readonly decimalSeparator: {
+        readonly fr: ",";
+        readonly en: ".";
+    };
+};
+export declare const allDecimalSeparators: ("." | ",")[];
+export type InputNumberPropsI18N = typeof inputNumberProps;
+export default inputNumberProps;

package/lib/src/index.d.ts

@@ -0,0 +1,3 @@
+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';

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

@@ -0,0 +1 @@
+export type Overwrite<T, U> = Omit<T, keyof U> & U;

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

@@ -0,0 +1,289 @@
+import { LunaticData, LunaticState } from './type';
+import { LunaticSource } from './type-source';
+import { SuggesterStatus } from './use-suggesters';
+export declare enum ActionKind {
+    GO_PREVIOUS_PAGE = "use-lunatic/go-previous",
+    GO_NEXT_PAGE = "use-lunatic/go-next",
+    GO_TO_PAGE = "use-lunatic/go-to-page",
+    ON_INIT = "use-lunatic/on-init",
+    HANDLE_CHANGE = "use-lunatic/handle-change",
+    ON_SET_WAITING = "use-lunatic/on-set-waiting",
+    UPDATE_STATE = "use-lunatic/update-state"
+}
+export type ActionHandleChange = {
+    type: ActionKind.HANDLE_CHANGE;
+    payload: {
+        response: {
+            name: string;
+        };
+        value: unknown;
+        args?: {
+            loop?: boolean;
+            length?: number;
+            index?: number;
+            linksIterations?: number[];
+            symLinks?: {
+                [variableName: string]: Record<string, string>;
+            };
+            paginatedLoop?: unknown;
+            shallowIteration?: unknown;
+            lengths?: number[];
+        };
+    };
+};
+export type ActionGoToPage = {
+    type: ActionKind.GO_TO_PAGE;
+    payload: Parameters<LunaticState['goToPage']>[0];
+};
+export type ActionInit = {
+    type: ActionKind.ON_INIT;
+    payload: {
+        data: LunaticData;
+        source: LunaticSource;
+        initialPage: string;
+        features: LunaticState['features'];
+        preferences: LunaticState['preferences'];
+        savingType: LunaticState['savingType'];
+        shortcut: boolean;
+        management: boolean;
+        handleChange: LunaticState['handleChange'];
+        activeControls: boolean;
+        goToPage: (params: ActionGoToPage['payload']) => ActionGoToPage;
+        withOverview: boolean;
+    };
+};
+export type ActionOnSetWaiting = {
+    type: ActionKind.ON_SET_WAITING;
+    payload: {
+        status: boolean;
+    };
+};
+export type ActionUpdateState = {
+    type: ActionKind.UPDATE_STATE;
+    payload: {
+        getSuggesterStatus: (name: string) => {
+            status: SuggesterStatus;
+            timestamp: number;
+        };
+    };
+};
+export type ActionGoNextPage = {
+    type: ActionKind.GO_NEXT_PAGE;
+    payload: {
+        block?: unknown;
+    };
+};
+export type ActionGoPreviousPage = {
+    type: ActionKind.GO_PREVIOUS_PAGE;
+    payload: {};
+};
+export type Action = ActionGoNextPage | ActionGoPreviousPage | ActionGoToPage | ActionInit | ActionHandleChange | ActionOnSetWaiting | ActionUpdateState;
+export type PayloadForAction<T extends Action['type']> = (Action & {
+    type: T;
+})['payload'];
+export declare const goPreviousPage: () => {
+    readonly type: ActionKind.GO_PREVIOUS_PAGE;
+    readonly payload: {};
+};
+export declare const goNextPage: (payload: {} | {
+    page: string;
+    iteration?: number | undefined;
+    nbIterations?: number | undefined;
+    subPage?: number | undefined;
+    roundabout?: {
+        page: string;
+    } | undefined;
+} | {
+    response: {
+        name: string;
+    };
+    value: unknown;
+    args?: {
+        loop?: boolean | undefined;
+        length?: number | undefined;
+        index?: number | undefined;
+        linksIterations?: number[] | undefined;
+        symLinks?: {
+            [variableName: string]: Record<string, string>;
+        } | undefined;
+        paginatedLoop?: unknown;
+        shallowIteration?: unknown;
+        lengths?: number[] | undefined;
+    } | undefined;
+} | {
+    data: LunaticData;
+    source: LunaticSource;
+    initialPage: string;
+    features: LunaticState['features'];
+    preferences: LunaticState['preferences'];
+    savingType: LunaticState['savingType'];
+    shortcut: boolean;
+    management: boolean;
+    handleChange: LunaticState['handleChange'];
+    activeControls: boolean;
+    goToPage: (params: ActionGoToPage['payload']) => ActionGoToPage;
+    withOverview: boolean;
+} | {
+    status: boolean;
+} | {
+    getSuggesterStatus: (name: string) => {
+        status: SuggesterStatus;
+        timestamp: number;
+    };
+} | {
+    block?: unknown;
+}) => ActionGoNextPage & {
+    type: ActionKind.GO_NEXT_PAGE;
+};
+export declare const goToPage: (payload: {} | {
+    page: string;
+    iteration?: number | undefined;
+    nbIterations?: number | undefined;
+    subPage?: number | undefined;
+    roundabout?: {
+        page: string;
+    } | undefined;
+} | {
+    response: {
+        name: string;
+    };
+    value: unknown;
+    args?: {
+        loop?: boolean | undefined;
+        length?: number | undefined;
+        index?: number | undefined;
+        linksIterations?: number[] | undefined;
+        symLinks?: {
+            [variableName: string]: Record<string, string>;
+        } | undefined;
+        paginatedLoop?: unknown;
+        shallowIteration?: unknown;
+        lengths?: number[] | undefined;
+    } | undefined;
+} | {
+    data: LunaticData;
+    source: LunaticSource;
+    initialPage: string;
+    features: LunaticState['features'];
+    preferences: LunaticState['preferences'];
+    savingType: LunaticState['savingType'];
+    shortcut: boolean;
+    management: boolean;
+    handleChange: LunaticState['handleChange'];
+    activeControls: boolean;
+    goToPage: (params: ActionGoToPage['payload']) => ActionGoToPage;
+    withOverview: boolean;
+} | {
+    status: boolean;
+} | {
+    getSuggesterStatus: (name: string) => {
+        status: SuggesterStatus;
+        timestamp: number;
+    };
+} | {
+    block?: unknown;
+}) => ActionGoToPage & {
+    type: ActionKind.GO_TO_PAGE;
+};
+export declare const onInit: (payload: {} | {
+    page: string;
+    iteration?: number | undefined;
+    nbIterations?: number | undefined;
+    subPage?: number | undefined;
+    roundabout?: {
+        page: string;
+    } | undefined;
+} | {
+    response: {
+        name: string;
+    };
+    value: unknown;
+    args?: {
+        loop?: boolean | undefined;
+        length?: number | undefined;
+        index?: number | undefined;
+        linksIterations?: number[] | undefined;
+        symLinks?: {
+            [variableName: string]: Record<string, string>;
+        } | undefined;
+        paginatedLoop?: unknown;
+        shallowIteration?: unknown;
+        lengths?: number[] | undefined;
+    } | undefined;
+} | {
+    data: LunaticData;
+    source: LunaticSource;
+    initialPage: string;
+    features: LunaticState['features'];
+    preferences: LunaticState['preferences'];
+    savingType: LunaticState['savingType'];
+    shortcut: boolean;
+    management: boolean;
+    handleChange: LunaticState['handleChange'];
+    activeControls: boolean;
+    goToPage: (params: ActionGoToPage['payload']) => ActionGoToPage;
+    withOverview: boolean;
+} | {
+    status: boolean;
+} | {
+    getSuggesterStatus: (name: string) => {
+        status: SuggesterStatus;
+        timestamp: number;
+    };
+} | {
+    block?: unknown;
+}) => ActionInit & {
+    type: ActionKind.ON_INIT;
+};
+export declare const handleChange: (response: ActionHandleChange['payload']['response'], value: ActionHandleChange['payload']['value'], args: ActionHandleChange['payload']['args']) => Action;
+export declare const onSetWaiting: (status: boolean) => Action;
+export declare const updateState: (payload: {} | {
+    page: string;
+    iteration?: number | undefined;
+    nbIterations?: number | undefined;
+    subPage?: number | undefined;
+    roundabout?: {
+        page: string;
+    } | undefined;
+} | {
+    response: {
+        name: string;
+    };
+    value: unknown;
+    args?: {
+        loop?: boolean | undefined;
+        length?: number | undefined;
+        index?: number | undefined;
+        linksIterations?: number[] | undefined;
+        symLinks?: {
+            [variableName: string]: Record<string, string>;
+        } | undefined;
+        paginatedLoop?: unknown;
+        shallowIteration?: unknown;
+        lengths?: number[] | undefined;
+    } | undefined;
+} | {
+    data: LunaticData;
+    source: LunaticSource;
+    initialPage: string;
+    features: LunaticState['features'];
+    preferences: LunaticState['preferences'];
+    savingType: LunaticState['savingType'];
+    shortcut: boolean;
+    management: boolean;
+    handleChange: LunaticState['handleChange'];
+    activeControls: boolean;
+    goToPage: (params: ActionGoToPage['payload']) => ActionGoToPage;
+    withOverview: boolean;
+} | {
+    status: boolean;
+} | {
+    getSuggesterStatus: (name: string) => {
+        status: SuggesterStatus;
+        timestamp: number;
+    };
+} | {
+    block?: unknown;
+}) => ActionUpdateState & {
+    type: ActionKind.UPDATE_STATE;
+};

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

@@ -0,0 +1,8 @@
+import { LunaticState, LunaticValues } from '../type';
+export declare const interpretAllCalculatedVariables: ({ variables, partialVariables, builtVariables, }: {
+    variables: LunaticState['variables'];
+    builtVariables: LunaticValues;
+    partialVariables?: {
+        [variableName: string]: import("../type").LunaticStateVariable;
+    } | undefined;
+}) => LunaticValues;

package/lib/src/use-lunatic/commons/check-loops.d.ts

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

package/lib/src/use-lunatic/commons/check-pager.d.ts

@@ -0,0 +1,5 @@
+import { LunaticState } from '../type';
+/**
+ * Reset the pager at his initial state
+ */
+export default function clearPager(pager: LunaticState['pager']): LunaticState['pager'];

package/lib/src/use-lunatic/commons/compile-controls.d.ts

@@ -0,0 +1,7 @@
+import { LunaticError, LunaticState } from '../type';
+export type StateForControls = Pick<LunaticState, 'pager' | 'pages' | 'isInLoop' | 'executeExpression'>;
+declare function computeErrors(state: StateForControls): {
+    currentErrors: Record<string, LunaticError[]> | undefined;
+    isCritical: boolean;
+};
+export default computeErrors;

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

@@ -0,0 +1,3 @@
+import { LunaticState } from '../type';
+declare const compose: <V>(...functions: ((acc: LunaticState, action: V) => LunaticState)[]) => (acc: LunaticState, action: V) => LunaticState;
+export default compose;

package/lib/src/use-lunatic/commons/create-map-pages.d.ts

@@ -0,0 +1,7 @@
+import { LunaticState } from '../type';
+import { LunaticSource } from '../type-source';
+/**
+ * Extract pages from questionnaire
+ */
+declare function createPages(questionnaire: LunaticSource): LunaticState['pages'];
+export default createPages;

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

@@ -0,0 +1,3 @@
+import { LunaticExpression, LunaticState } from '../type';
+declare function executeConditionFilter(filter: LunaticExpression, execute: LunaticState['executeExpression'], iteration?: number): unknown;
+export default executeConditionFilter;

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

@@ -0,0 +1,9 @@
+import { LunaticExpression, LunaticState } from '../../type';
+export type ExpressionLogger = (expression: string | LunaticExpression, bindings: {
+    [variableName: string]: unknown;
+}, e: unknown) => void;
+/**
+ * Generates methods to interact with variables
+ */
+declare function createExecuteExpression(variables: LunaticState['variables'], features: string[]): readonly [<T = unknown>(expObject: unknown, args?: Parameters<LunaticState['executeExpression']>[1]) => T, (name: string, value: unknown) => void];
+export default createExecuteExpression;

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

@@ -0,0 +1,8 @@
+type Bindings = {
+    [variableName: string]: unknown;
+};
+/**
+ * To avoid performance issue when recalculating expression, memoise the value for every expression, binding combo
+ */
+declare function createMemoizer(): readonly [(expression: string, bindings: Bindings, value: unknown) => void, (expression: string, bindings: Bindings) => any];
+export default createMemoizer;

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

@@ -0,0 +1,24 @@
+import { LunaticState, LunaticVariable } from '../../type';
+import { ExpressionLogger } from './create-execute-expression';
+type Args = {
+    variables: LunaticState['variables'];
+    bindings: {
+        [variableName: string]: unknown;
+    };
+    execute: (expObject: unknown, args: {
+        iteration?: number;
+        linksIterations?: number[];
+        logging?: ExpressionLogger;
+    }) => unknown;
+};
+/**
+ * Refresh calculated variables with the new value in the bindings
+ */
+declare function createRefreshCalculated({ variables, execute, bindings }: Args): readonly [(map: {
+    [variableName: string]: unknown;
+}, { rootExpression, iteration, linksIterations, }: {
+    rootExpression?: string | undefined;
+    iteration?: number | undefined;
+    linksIterations?: number[] | undefined;
+}) => {}, (name: string, variable: LunaticVariable) => void];
+export default createRefreshCalculated;

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

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+import { VTLBindings } from '../../type';
+/**
+ * Run a VTL expression and return the result
+ */
+export declare function executeVtlExpression<T = unknown>(expression: string, vtlBindings: {
+    [variableName: string]: unknown;
+}): unknown;
+declare function loggingDefault(expression: string, bindings: VTLBindings, e: unknown): void;
+declare function executeExpression(vtlBindings: VTLBindings, expression: string, type: 'VTL' | 'VTL|MD', features: string[], logging?: typeof loggingDefault): ReactNode;
+export default executeExpression;

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

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

package/lib/src/use-lunatic/commons/execute-expression/get-expressions-variables.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Find variables used in an expression
+ */
+declare function getExpressionVariables(expression: string, variables: {
+    [variableName: string]: unknown;
+}): string[];
+export default getExpressionVariables;

package/lib/src/use-lunatic/commons/execute-expression/get-expressions-variables.spec.d.ts

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

package/lib/src/use-lunatic/commons/execute-expression/get-safety-expression.d.ts

@@ -0,0 +1,6 @@
+import { LunaticExpression } from '../../type';
+/**
+ * Convert an unknown variable into a valid VTL expression object
+ */
+declare function getSafetyExpression(expression: unknown): LunaticExpression;
+export default getSafetyExpression;

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

@@ -0,0 +1 @@
+export { default } from './create-execute-expression';

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

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+import { LunaticComponentDefinition, LunaticExpression, LunaticState } from '../../type';
+export type DeepTranslateExpression<T> = T extends LunaticExpression ? ReactNode : T extends {
+    [k: string | number]: unknown;
+} ? {
+    [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">;
+export default fillComponentExpressions;

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

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

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

@@ -0,0 +1,6 @@
+import { LunaticComponentDefinition, LunaticState } from '../../type';
+export type FilledProps = {
+    value: unknown;
+};
+declare function fillComponentValue(component: LunaticComponentDefinition, state: LunaticState): LunaticComponentDefinition & FilledProps;
+export default fillComponentValue;

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

@@ -0,0 +1,12 @@
+import { LunaticComponentDefinition, LunaticState } from '../../type';
+import { DeepTranslateExpression } from './fill-component-expressions';
+import { FilledProps as FilledValueProps } from './fill-component-value';
+import { FilledProps as FilledHandlersProps } from './fill-from-state';
+import { FilledProps as FilledManagementProps } from './fill-management';
+import { FilledProps as FilledMissingResponseProps } from './fill-missing-response';
+import { FilledProps as FilledPaginationProps } from './fill-pagination';
+export type LunaticComponentProps<T = LunaticComponentDefinition['componentType']> = DeepTranslateExpression<LunaticComponentDefinition & {
+    componentType: T;
+}> & FilledManagementProps & FilledValueProps & FilledMissingResponseProps & FilledHandlersProps & FilledPaginationProps;
+declare function fillComponents(components: LunaticComponentDefinition[], state: LunaticState): LunaticComponentProps[];
+export default fillComponents;