@inseefr/lunatic 3.0.0-rc.19 → 3.0.0-rc.21

package/lib/use-lunatic/reducer/reduce-on-set-waiting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduce-on-set-waiting.js","sourceRoot":"","sources":["../../../src/use-lunatic/reducer/reduce-on-set-waiting.ts"],"names":[],"mappings":"AACA,OAAO,EAA2B,MAAM,YAAY,CAAC;AAErD,SAAS,kBAAkB,CAC1B,KAAmB,EACnB,MAA0B;IAE1B,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC;IAC3B,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;IAC3B,OAAO,EAAE,GAAG,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;AACtC,CAAC;AAED,eAAe,kBAAkB,CAAC"}

package/lib/use-lunatic/reducer/reducer.js

@@ -0,0 +1,27 @@
+import { ActionKind } from '../actions';
+import { reduceGoNextPage } from './reduce-go-next-page';
+import reduceGoPreviousPage from './reduce-go-previous-page';
+import reduceGoToPage from './reduce-go-to-page';
+import { reduceHandleChange } from './reduce-handle-change';
+import reduceOnInit from './reduce-on-init';
+import reduceOnSetWaiting from './reduce-on-set-waiting';
+function reducer(state, action) {
+    switch (action.type) {
+        case ActionKind.ON_INIT:
+            return reduceOnInit(state, action);
+        case ActionKind.GO_PREVIOUS_PAGE:
+            return reduceGoPreviousPage(state);
+        case ActionKind.GO_NEXT_PAGE:
+            return reduceGoNextPage(state);
+        case ActionKind.GO_TO_PAGE:
+            return reduceGoToPage(state, action);
+        case ActionKind.HANDLE_CHANGE:
+            return reduceHandleChange(state, action);
+        case ActionKind.ON_SET_WAITING:
+            return reduceOnSetWaiting(state, action);
+        default:
+            return state;
+    }
+}
+export default reducer;
+//# sourceMappingURL=reducer.js.map

package/lib/use-lunatic/reducer/reducer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reducer.js","sourceRoot":"","sources":["../../../src/use-lunatic/reducer/reducer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAe,MAAM,YAAY,CAAC;AAErD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,oBAAoB,MAAM,2BAA2B,CAAC;AAC7D,OAAO,cAAc,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,YAAY,MAAM,kBAAkB,CAAC;AAC5C,OAAO,kBAAkB,MAAM,yBAAyB,CAAC;AAEzD,SAAS,OAAO,CAAC,KAAmB,EAAE,MAAc;IACnD,QAAQ,MAAM,CAAC,IAAI,EAAE,CAAC;QACrB,KAAK,UAAU,CAAC,OAAO;YACtB,OAAO,YAAY,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QACpC,KAAK,UAAU,CAAC,gBAAgB;YAC/B,OAAO,oBAAoB,CAAC,KAAK,CAAC,CAAC;QACpC,KAAK,UAAU,CAAC,YAAY;YAC3B,OAAO,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAChC,KAAK,UAAU,CAAC,UAAU;YACzB,OAAO,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QACtC,KAAK,UAAU,CAAC,aAAa;YAC5B,OAAO,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QAC1C,KAAK,UAAU,CAAC,cAAc;YAC7B,OAAO,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QAC1C;YACC,OAAO,KAAK,CAAC;IACf,CAAC;AACF,CAAC;AAED,eAAe,OAAO,CAAC"}

package/lib/use-lunatic/replace-component-sequence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replace-component-sequence.js","sourceRoot":"","sources":["../../src/use-lunatic/replace-component-sequence.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,UAAU,wBAAwB,CACvC,UAA6C;IAE7C,OAAO,UAAU,CAAC,MAAM,CAAC,UACxB,GAAsC,EACtC,SAAS;QAET,MAAM,EAAE,aAAa,EAAE,GAAG,SAAS,CAAC;QACpC,QAAQ,aAAa,EAAE,CAAC;YACvB,KAAK,UAAU;gBACd,OAAO,CAAC,GAAG,GAAG,EAAE,GAAG,SAAS,CAAC,UAAU,CAAC,CAAC;YAC1C;gBACC,OAAO,CAAC,GAAG,GAAG,EAAE,SAAS,CAAC,CAAC;QAC7B,CAAC;IACF,CAAC,EAAE,EAAE,CAAC,CAAC;AACR,CAAC"}

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

@@ -0,0 +1,314 @@
+/**
+ * Types used for source data (lunatic models and data.json)
+ */
+export type LabelType<T extends 'VTL' | 'VTL|MD' = 'VTL' | 'VTL|MD'> = {
+    value: string;
+    type: T;
+};
+export type ValuesType<T = unknown> = {
+    PREVIOUS: T | null;
+    COLLECTED: T | null;
+    FORCED: T | null;
+    EDITED: T | null;
+    INPUTED: T | null;
+};
+export type ValuesTypeArray<T = unknown> = {
+    PREVIOUS: T[] | [null];
+    COLLECTED: T[] | [null];
+    FORCED: T[] | [null];
+    EDITED: T[] | [null];
+    INPUTED: T[] | [null];
+};
+export type DeclarationType = {
+    id: string;
+    declarationType: 'INSTRUCTION' | 'COMMENT' | 'HELP' | 'CODECARD' | 'WARNING' | 'STATEMENT';
+    position: 'AFTER_QUESTION_TEXT' | 'AFTER_RESPONSE' | 'BEFORE_QUESTION_TEXT' | 'DETACHABLE';
+    label: LabelType;
+};
+export type ConditionFilterType = LabelType & {
+    bindingDependencies?: string[];
+};
+export type ControlType = {
+    id: string;
+    criticality: 'INFO' | 'WARN' | 'ERROR';
+    typeOfControl: 'FORMAT' | 'CONSISTENCY';
+    control: LabelType;
+    errorMessage: LabelType;
+    bindingDependencies?: string[];
+    type?: 'roundabout' | 'ROW' | 'simple';
+    iterations?: number;
+};
+export type ResponseType = {
+    name: string;
+};
+export type SequenceDescription = {
+    label: LabelType;
+    id: string;
+    page: string;
+};
+export type Hierarchy = {
+    sequence: SequenceDescription;
+    subSequence?: SequenceDescription;
+};
+export type ComponentTypeBase = {
+    label: LabelType;
+    description?: LabelType;
+    declarations?: DeclarationType[];
+    conditionFilter?: ConditionFilterType;
+    controls?: ControlType[];
+    id: string;
+    bindingDependencies?: string[];
+    hierarchy?: Hierarchy;
+    mandatory?: boolean;
+    page: string;
+};
+export type ComponentType = (ComponentTypeBase & ComponentSequenceType) | (ComponentTypeBase & ComponentSubSequenceType) | (ComponentTypeBase & ComponentRosterForLoopType) | (ComponentTypeBase & ComponentLoopType) | (ComponentTypeBase & ComponentTableType) | (ComponentTypeBase & ComponentNumberType) | (ComponentTypeBase & ComponentDatePickerType) | (ComponentTypeBase & ComponentDurationType) | (ComponentTypeBase & ComponentCheckboxGroupType) | (ComponentTypeBase & ComponentCheckboxBooleanType) | (ComponentTypeBase & ComponentRadioType) | (ComponentTypeBase & ComponentFilterDescriptionType) | (ComponentTypeBase & ComponentDropdownType) | (Omit<ComponentTypeBase, 'label'> & ComponentPairWiseLinksType) | (ComponentTypeBase & ComponentRoundaboutType) | (ComponentTypeBase & ComponentSuggesterType) | (ComponentTypeBase & ComponentInputOrTextareaType) | (ComponentTypeBase & ComponentCheckboxOneType) | (ComponentTypeBase & ComponentQuestionType);
+export type ComponentTypeEnum = ComponentType['componentType'];
+export type ComponentInputOrTextareaType = {
+    componentType: 'Input' | 'Textarea';
+    maxLength: number;
+    missingResponse?: ResponseType;
+    response: ResponseType;
+};
+export type ComponentSequenceType = {
+    componentType: 'Sequence';
+    gotoPage?: string;
+};
+export type ComponentSubSequenceType = {
+    componentType: 'Subsequence';
+};
+export type ComponentRoundaboutType = {
+    componentType: 'Roundabout';
+    components: ComponentType[];
+    iterations: LabelType;
+    locked: boolean;
+    expressions: Record<string, LabelType>;
+};
+export type ComponentRosterForLoopType = {
+    componentType: 'RosterForLoop';
+    components: ComponentType[];
+    lines: {
+        min: LabelType;
+        max: LabelType;
+    };
+    header?: {
+        value: string;
+        label: LabelType | string;
+        options: Options;
+        colspan?: number;
+        rowspan?: number;
+    }[];
+    positioning: 'HORIZONTAL';
+};
+type PaginatedLoop = {
+    paginatedLoop: true;
+    maxPage: string;
+    iterations: LabelType;
+};
+type BlockLoop = {
+    paginatedLoop: false;
+    lines: {
+        min: LabelType;
+        max: LabelType;
+    };
+};
+export type ComponentLoopType = {
+    componentType: 'Loop';
+    loopDependencies: string[];
+    components: ComponentType[];
+    depth: number;
+} & (PaginatedLoop | BlockLoop);
+export type ComponentTableType = {
+    componentType: 'Table';
+    header: ComponentRosterForLoopType['header'];
+    body: ({
+        label: LabelType;
+        colspan?: number;
+        rowspan?: number;
+    } | (ComponentType & {
+        colspan?: number;
+        rowspan?: number;
+    }))[][];
+};
+export type ComponentNumberType = {
+    componentType: 'InputNumber';
+    unit?: string;
+    response: ResponseType;
+    min?: number;
+    max?: number;
+    decimals?: number;
+};
+export type ComponentDatePickerType = {
+    componentType: 'Datepicker';
+    dateFormat: 'YYYY-MM-DD' | 'YYYY' | 'YYYY-MM';
+    response: ResponseType;
+    min?: string;
+    max?: string;
+};
+export type ComponentDurationType = {
+    componentType: 'Duration';
+    format: 'PnYnM' | 'PTnHnM';
+    response: ResponseType;
+};
+export type ComponentCheckboxGroupType = {
+    componentType: 'CheckboxGroup';
+    description?: LabelType;
+    responses: Array<{
+        label: LabelType;
+        description?: LabelType;
+        response: ResponseType;
+        id: string;
+    }>;
+};
+export type ComponentCheckboxBooleanType = {
+    componentType: 'CheckboxBoolean';
+    response: ResponseType;
+    missingResponse?: ResponseType;
+};
+type Options = {
+    value: string;
+    label: LabelType;
+    description?: LabelType;
+}[];
+export type ComponentCheckboxOneType = {
+    componentType: 'CheckboxOne';
+    response: ResponseType;
+    missingResponse?: ResponseType;
+    options: Options;
+};
+export type ComponentRadioType = {
+    componentType: 'Radio';
+    options: Options;
+    response: ResponseType;
+    missingResponse?: ResponseType;
+};
+export type ComponentDropdownType = {
+    componentType: 'Dropdown';
+    options: Options;
+    response: ResponseType;
+    missingResponse?: ResponseType;
+};
+export type ComponentFilterDescriptionType = {
+    componentType: 'FilterDescription';
+    filterDescription: boolean;
+};
+export type ComponentPairWiseLinksType = {
+    componentType: 'PairwiseLinks';
+    xAxisIterations: LabelType;
+    yAxisIterations: LabelType;
+    symLinks: {
+        [variableName: string]: Record<string, string | null>;
+    };
+    components: ComponentType[];
+};
+export type ComponentQuestionType = {
+    componentType: 'Question';
+    components: ComponentType[];
+    description: LabelType;
+};
+export type ComponentSuggesterType = {
+    componentType: 'Suggester';
+    storeName: string;
+    response: ResponseType;
+    arbitrary?: {
+        response: {
+            name: string;
+        };
+    };
+    optionResponses: {
+        name: string;
+        attribute: string;
+    }[];
+};
+export type SuggesterType = {
+    name: string;
+    fields: {
+        name: string;
+        min?: number;
+        rules?: 'soft' | string[];
+        language?: 'French' | 'English';
+        stemmer?: boolean;
+        synonyms?: {
+            [source: string]: string[];
+        };
+    }[];
+    max?: number;
+    stopWords?: string;
+    order?: {
+        field: string;
+        type: string;
+    };
+    queryParser: {
+        type: 'tokenized';
+        params: {
+            language: 'French' | 'English';
+            pattern: string;
+            min?: number;
+        };
+    } | {
+        type: 'soft';
+        params: undefined;
+    };
+    url?: string;
+    version: number;
+    meloto?: boolean;
+};
+export type Variable = {
+    variableType: 'EXTERNAL';
+    name: string;
+    value: unknown;
+} | {
+    variableType: 'COLLECTED';
+    name: string;
+    values: ValuesType | ValuesTypeArray;
+} | {
+    variableType: 'CALCULATED';
+    name: string;
+    expression: LabelType;
+    bindingDependencies?: string[];
+    inFilter: string;
+    shapeFrom?: string;
+};
+export type LunaticSource = {
+    id: string;
+    modele?: string;
+    enoCoreVersion?: string;
+    lunaticModelVersion?: string;
+    generatingDate?: string;
+    missing?: boolean;
+    pagination?: 'question' | 'sequence' | 'subsequence';
+    maxPage: string;
+    label: LabelType;
+    components: ComponentType[];
+    variables: Variable[];
+    suggesters?: SuggesterType[];
+    cleaning: {
+        [variableName: string]: {
+            [variableName: string]: string;
+        };
+    };
+    missingBlock?: {
+        [variableName: string]: string[];
+    };
+    resizing: {
+        [variableName: string]: {
+            size: string;
+            variables: string[];
+        } | {
+            sizeForLinksVariables: [string, string] | {
+                xAxisSize: string;
+                yAxisSize: string;
+            };
+            linksVariables: string[];
+        } | {
+            size: string;
+            variables: string[];
+            sizeForLinksVariables: [string, string] | {
+                xAxisSize: string;
+                yAxisSize: string;
+            };
+            linksVariables: string[];
+        };
+    };
+};
+export {};

package/lib/use-lunatic/type-source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-source.js","sourceRoot":"","sources":["../../src/use-lunatic/type-source.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,143 @@
+import type { ReactNode } from 'react';
+import type { ComponentType, ControlType, LunaticSource, Variable } from './type-source';
+import type { LunaticVariablesStore } from './commons/variables/lunatic-variables-store';
+export type LunaticComponentDefinition<T extends ComponentType['componentType'] = ComponentType['componentType']> = ComponentType & {
+    componentType: T;
+};
+export type LunaticControl = ControlType;
+export type VTLBindings = {
+    [variableName: string]: unknown;
+};
+export type LunaticData = Partial<Record<Exclude<VariableType, 'COLLECTED'>, Record<string, unknown>> & {
+    COLLECTED: Record<string, LunaticCollectedValue>;
+}>;
+export type LunaticValues = {
+    [variableName: string]: unknown;
+};
+export type LunaticError = Pick<ControlType, 'id' | 'criticality' | 'typeOfControl'> & {
+    errorMessage: ReactNode;
+};
+export type VariableType = 'COLLECTED' | 'EXTERNAL' | 'CALCULATED';
+export type ExpressionType = 'VTL' | 'VTL|MD';
+export type LunaticExpression = {
+    value: string;
+    type: ExpressionType;
+    bindingDependencies?: string[];
+};
+export type TODO = unknown;
+export type PageTag = `${number}.${number}#${number}` | `${number}`;
+export type LunaticVariable = Variable;
+export type LunaticCollectedValue = Partial<{
+    COLLECTED: unknown;
+    EDITED: unknown;
+    FORCED: unknown;
+    INPUTED: unknown;
+    PREVIOUS: unknown;
+}>;
+export type LunaticOverviewItem = {
+    id: string;
+    page: string;
+    type: string;
+    evaluatedLabel: string;
+    visible: boolean;
+    reached: boolean;
+    parent?: unknown;
+    label: LunaticExpression;
+    conditionFilter?: {
+        bindingDependencies?: string[];
+    };
+    children: LunaticOverviewItem[];
+};
+export type LunaticStateVariable = {
+    [key in LunaticVariable['variableType']]: {
+        type: key;
+        value: unknown;
+        variable: LunaticVariable & {
+            variableType: key;
+        };
+        CalculatedLinked?: LunaticVariable[];
+    };
+}[LunaticVariable['variableType']];
+export type LunaticState = {
+    updatedAt: number;
+    variables: LunaticVariablesStore;
+    pages: {
+        [key: number | string]: {
+            components: ComponentType[];
+            isLoop: false;
+            iterations?: undefined;
+            loopDependencies?: undefined;
+            subPages?: undefined;
+        } | {
+            components: ComponentType[];
+            isLoop: true;
+            iterations: ExpressionType;
+            loopDependencies: string[];
+            subPages: string[];
+        };
+    };
+    isInLoop: boolean;
+    isFirstPage: boolean;
+    isLastPage: boolean;
+    features: ['VTL'] | ['VTL', 'MD'];
+    preferences: ['COLLECTED'];
+    savingType: 'COLLECTED';
+    cleaning: LunaticSource['cleaning'];
+    missingBlock: {
+        [variable: string]: string[];
+    };
+    resizing: {
+        [variable: string]: {
+            size: string;
+            variables: string[];
+            sizeForLinksVariables?: unknown;
+            linksVariables?: string[];
+        };
+    };
+    overview: LunaticOverviewItem[];
+    pager: {
+        lastReachedPage?: PageTag;
+        maxPage: number;
+        nbSubPages?: number;
+        page: number;
+        subPage?: number;
+        iteration?: number;
+        nbIterations?: number;
+        shallowIteration?: number;
+        linksIterations?: number[];
+    };
+    waiting: boolean;
+    errors?: {
+        [page: string]: {
+            [id: string]: LunaticError[];
+        };
+    };
+    currentErrors?: {
+        [id: string]: LunaticError[];
+    };
+    modalErrors?: Record<string, LunaticError[]>;
+    handleChange: (response: {
+        name: string;
+    }, value: any, args?: {
+        iteration?: number[];
+    }) => void;
+    executeExpression: <T extends unknown = unknown>(expression: unknown, args?: {
+        iteration?: number | number[];
+        bindingDependencies?: string[];
+        deps?: string[];
+    }) => T;
+    updateBindings: (variableName: string, value: unknown, options: {
+        iteration?: number[];
+    }) => unknown;
+    activeControls: boolean;
+    shortcut?: boolean;
+    management?: boolean;
+    goToPage: (page: {
+        page: PageTag | number;
+        iteration?: number;
+        nbIterations?: number;
+        subPage?: number;
+    }) => void;
+    goNextPage: () => void;
+    goPreviousPage: () => void;
+};

package/lib/use-lunatic/type.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=type.js.map

package/lib/use-lunatic/type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.js","sourceRoot":"","sources":["../../src/use-lunatic/type.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,107 @@
+/// <reference types="react" />
+import type { LunaticState, PageTag } from './type';
+import type { LunaticSource } from './type-source';
+import type { LunaticComponentProps } from '../components/type';
+import type { IndexEntry } from '../utils/search/SearchInterface';
+declare function useLunatic(source: LunaticSource, data: Partial<Record<"EXTERNAL" | "CALCULATED", Record<string, unknown>> & {
+    COLLECTED: Record<string, Partial<{
+        COLLECTED: unknown;
+        EDITED: unknown;
+        FORCED: unknown;
+        INPUTED: unknown;
+        PREVIOUS: unknown;
+    }>>;
+}> | undefined, { features, preferences, savingType, onChange, management, shortcut, initialPage, lastReachedPage, autoSuggesterLoading, activeControls, getReferentiel, withOverview, missing, missingStrategy, missingShortcut, dontKnowButton, refusedButton, trackChanges, }: {
+    features?: LunaticState['features'];
+    preferences?: LunaticState['preferences'];
+    savingType?: LunaticState['savingType'];
+    onChange?: LunaticState['handleChange'];
+    management?: boolean;
+    shortcut?: boolean;
+    initialPage?: PageTag;
+    lastReachedPage?: PageTag;
+    autoSuggesterLoading?: boolean;
+    getReferentiel?: (name: string) => Promise<Array<IndexEntry>>;
+    activeControls?: boolean;
+    withOverview?: boolean;
+    missing?: boolean;
+    missingStrategy?: () => void;
+    missingShortcut?: {
+        dontKnow: string;
+        refused: string;
+    };
+    dontKnowButton?: string;
+    refusedButton?: string;
+    trackChanges?: boolean;
+}): {
+    getComponents: ({ only, except, }?: {
+        only?: LunaticComponentProps['componentType'];
+        except?: LunaticComponentProps['componentType'];
+    }) => LunaticComponentProps[];
+    goPreviousPage: () => void;
+    goNextPage: (payload?: {}) => void;
+    goToPage: (page: {
+        page: number | PageTag;
+        iteration?: number | undefined;
+        nbIterations?: number | undefined;
+        subPage?: number | undefined;
+    }) => void;
+    compileControls: () => {
+        currentErrors: Record<string, import("./type").LunaticError[]> | undefined;
+        isCritical: boolean;
+    };
+    pageTag: PageTag;
+    isFirstPage: boolean;
+    isLastPage: boolean;
+    pager: {
+        lastReachedPage?: PageTag | undefined;
+        maxPage: number;
+        nbSubPages?: number | undefined;
+        page: number;
+        subPage?: number | undefined;
+        iteration?: number | undefined;
+        nbIterations?: number | undefined;
+        shallowIteration?: number | undefined;
+        linksIterations?: number[] | undefined;
+    };
+    waiting: boolean;
+    getData: (withRefreshedCalculated: boolean, variableNames?: string[]) => Partial<Record<"EXTERNAL" | "CALCULATED", Record<string, unknown>> & {
+        COLLECTED: Record<string, Partial<{
+            COLLECTED: unknown;
+            EDITED: unknown;
+            FORCED: unknown;
+            INPUTED: unknown;
+            PREVIOUS: unknown;
+        }>>;
+    }>;
+    Provider: import("react").FunctionComponent<{
+        children?: import("react").ReactNode;
+    }>;
+    onChange: (response: {
+        name: string;
+    }, value: any, args?: {
+        iteration?: number[] | undefined;
+    } | undefined) => void;
+    overview: {
+        lunaticId: string;
+        page: string;
+        type: string;
+        label: string;
+        visible: boolean;
+        reached: boolean;
+        children: import("./commons/getOverview").OverviewItem[];
+    }[];
+    loopVariables: string[];
+    getChangedData: (reset?: boolean) => Partial<Record<"EXTERNAL" | "CALCULATED", Record<string, unknown>> & {
+        COLLECTED: Record<string, Partial<{
+            COLLECTED: unknown;
+            EDITED: unknown;
+            FORCED: unknown;
+            INPUTED: unknown;
+            PREVIOUS: unknown;
+        }>>;
+    }>;
+    resetChangedData: () => void;
+    hasPageResponse: () => boolean;
+};
+export default useLunatic;