@inseefr/lunatic 2.3.1 → 2.4.0

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

@@ -0,0 +1,281 @@
+/**
+ * Types used for source data (lunatic models and data.json)
+ *
+ * These types should not be used outside of use-lunatic
+ */
+export type LabelType = {
+    value: string;
+    type: 'VTL' | 'VTL|MD';
+};
+export type ComponentTypeEnum = 'Sequence' | 'Subsequence' | 'RosterForLoop' | 'Loop' | 'Table' | 'Input' | 'InputNumber' | 'Datepicker' | 'CheckboxGroup' | 'CheckboxOne' | 'CheckboxBoolean' | 'Radio' | 'Dropdown' | 'Textarea' | 'FilterDescription' | 'PairwiseLinks' | 'Suggester';
+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 declare enum Criticality {
+    INFO = "INFO",
+    WARN = "WARN",
+    ERROR = "ERROR"
+}
+export declare enum TypeOfControl {
+    FORMAT = "FORMAT",
+    CONSISTENCY = "CONSISTENCY"
+}
+export type ControlType = {
+    id: string;
+    criticality: Criticality;
+    typeOfControl: TypeOfControl;
+    control: LabelType;
+    errorMessage: LabelType;
+    bindingDependencies: string[];
+};
+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;
+    declarations: DeclarationType[];
+    conditionFilter: ConditionFilterType;
+    controls?: ControlType[];
+    id: string;
+    storeName: string;
+    bindingDependencies: string[];
+    hierarchy: Hierarchy;
+    missingResponse: ResponseType;
+    mandatory?: boolean;
+    page: string;
+};
+export type ComponentType = (ComponentTypeBase & ComponentSequenceType) | (ComponentTypeBase & ComponentSubSequenceType) | (ComponentTypeBase & ComponentRosterForLoopType) | (ComponentTypeBase & ComponentLoopType) | (ComponentTypeBase & ComponentTableType) | (ComponentTypeBase & ComponentNumberType) | (ComponentTypeBase & ComponentDatePickerType) | (ComponentTypeBase & ComponentCheckboxGroupType) | (ComponentTypeBase & ComponentCheckboxBooleanType) | (ComponentTypeBase & ComponentRadioType) | (ComponentTypeBase & ComponentFilterDescriptionType) | (ComponentTypeBase & ComponentDropdownType) | (ComponentTypeBase & ComponentPairWiseLinksType) | (ComponentTypeBase & ComponentRoundaboutType) | (ComponentTypeBase & {
+    componentType: 'Input' | 'CheckboxOne' | 'Textarea';
+});
+export type ComponentSequenceType = {
+    componentType: 'Sequence';
+};
+export type ComponentSubSequenceType = {
+    componentType: 'Subsequence';
+    gotoPage: string;
+};
+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: {
+            value: string;
+            label: LabelType;
+        }[];
+        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;
+    }[];
+    positioning: 'HORIZONTAL';
+};
+export type ComponentLoopType = {
+    componentType: 'Loop';
+    loopDependencies: string[];
+    lines: {
+        min: LabelType;
+        max: LabelType;
+    };
+    components: ComponentType[];
+    iterations: LabelType;
+    maxPage: string;
+    depth: number;
+    paginatedLoop: boolean;
+};
+export type ComponentTableType = {
+    componentType: 'Table';
+    lines: ComponentRosterForLoopType['lines'];
+    header: ComponentRosterForLoopType['header'];
+    body: ComponentRosterForLoopType['body'];
+    positioning: ComponentRosterForLoopType['positioning'];
+};
+export type ComponentNumberType = {
+    componentType: 'InputNumber';
+    unit: string;
+    response: ResponseType;
+    min?: number;
+    max?: number;
+    decimals?: number;
+};
+export type ComponentDatePickerType = {
+    componentType: 'Datepicker';
+    dateFormat: string;
+    response: ResponseType;
+    min?: string;
+    max?: string;
+};
+export type ComponentCheckboxGroupType = {
+    componentType: 'CheckboxGroup';
+    responses: {
+        label: LabelType;
+        response: ResponseType;
+        id: string;
+    }[];
+};
+export type ComponentCheckboxBooleanType = {
+    componentType: 'CheckboxBoolean';
+    response: ResponseType;
+};
+export type ComponentRadioType = {
+    componentType: 'Radio';
+    options: {
+        value: string;
+        label: LabelType;
+    }[];
+    response: ResponseType;
+};
+export type ComponentDropdownType = {
+    componentType: 'Dropdown';
+    options: {
+        value: string;
+        label: LabelType;
+    }[];
+    response: ResponseType;
+};
+export type ComponentFilterDescriptionType = {
+    componentType: 'FilterDescription';
+    filterDescription: boolean;
+};
+export type ComponentPairWiseLinksType = {
+    componentType: 'PairwiseLinks';
+    xAxisIterations: LabelType;
+    yAxisIterations: LabelType;
+    symLinks: {
+        [variableName: string]: Record<string, string>;
+    };
+};
+export type SuggesterType = {
+    name: string;
+    fields: {
+        name: string;
+        min?: number;
+        rules?: string[];
+        language?: string;
+        stemmer?: boolean;
+        synonyms: {
+            source: string;
+            target: string[];
+        }[];
+    }[];
+    max: number;
+    stopWords?: string;
+    order?: {
+        field: string;
+        type: string;
+    };
+    queryParser: {
+        type: string;
+        params: {
+            language: string;
+            pattern: string;
+            min?: number;
+        };
+    };
+    url?: string;
+    version: number;
+};
+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?: boolean;
+    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[];
+        };
+    };
+};

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

@@ -0,0 +1,143 @@
+import { ReactNode } from 'react';
+import { ExpressionLogger } from './commons/execute-expression/create-execute-expression';
+import { ComponentType, ControlType, LunaticSource, Variable } from './type-source';
+import { SuggesterStatus } from './use-suggesters';
+export type LunaticComponentDefinition<T extends ComponentType['componentType'] = ComponentType['componentType']> = ComponentType & {
+    componentType: T;
+    errors?: Record<string, Array<LunaticError>>;
+};
+export type LunaticControl = ControlType;
+export type VTLBindings = {
+    [variableName: string]: unknown;
+};
+export type LunaticData = {
+    CALCULATED: Record<string, unknown>;
+    EXTERNAL: 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 LunaticVariable = Variable;
+export type LunaticCollectedValue = {
+    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 = {
+    variables: {
+        [variableName: string]: LunaticStateVariable;
+    };
+    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'[];
+    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?: string;
+        maxPage: string;
+        nbSubPages?: number;
+        page: string;
+        subPage?: number;
+        iteration?: number;
+        nbIterations?: number;
+        shallowIteration?: number;
+        linksIterations?: number[];
+        roundabout?: {
+            page: string;
+        };
+    };
+    waiting: boolean;
+    handleChange: (response: {
+        name: string;
+    }, value: unknown, args: Record<string, unknown>) => void;
+    executeExpression: <T extends unknown = unknown>(expression: unknown, args?: {
+        iteration?: number;
+        linksIterations?: number[];
+        logging?: ExpressionLogger;
+        bindingDependencies?: string[];
+    }) => T;
+    updateBindings: (variableName: string, value: unknown) => unknown;
+    activeControls: boolean;
+    shortcut?: boolean;
+    management?: boolean;
+    goToPage: (page: {
+        page: string;
+        iteration?: number;
+        nbIterations?: number;
+        subPage?: number;
+        roundabout?: {
+            page: string;
+        };
+    }) => void;
+    getSuggesterStatus: (name: string) => {
+        status: SuggesterStatus;
+        timestamp: number;
+    };
+};

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

@@ -0,0 +1,84 @@
+import { FunctionComponent } from 'react';
+import { LunaticData, LunaticState } from './type';
+import { LunaticSource } from './type-source';
+declare const nothing: LunaticState['handleChange'];
+declare function useLunatic(source: LunaticSource, data: LunaticData | undefined, { features, preferences, savingType, onChange, management, shortcut, initialPage, autoSuggesterLoading, activeControls, getReferentiel, custom, withOverview, missing, missingStrategy, missingShortcut, dontKnowButton, refusedButton, }: {
+    features?: string[];
+    preferences?: string[];
+    savingType?: string;
+    onChange?: typeof nothing;
+    management?: boolean;
+    shortcut?: boolean;
+    initialPage?: string;
+    autoSuggesterLoading?: boolean;
+    getReferentiel?: (name: string) => Promise<Array<unknown>>;
+    activeControls?: boolean;
+    custom?: Record<string, FunctionComponent<unknown>>;
+    withOverview?: boolean;
+    missing?: boolean;
+    missingStrategy?: () => void;
+    missingShortcut?: {
+        dontKnow: string;
+        refused: string;
+    };
+    dontKnowButton?: string;
+    refusedButton?: string;
+}): {
+    getComponents: () => import("./commons/fill-components/fill-components").LunaticComponentProps<"CheckboxGroup" | "Sequence" | "Subsequence" | "RosterForLoop" | "Loop" | "Table" | "Input" | "InputNumber" | "Datepicker" | "CheckboxOne" | "CheckboxBoolean" | "Radio" | "Dropdown" | "Textarea" | "FilterDescription" | "PairwiseLinks" | "Roundabout">[];
+    goPreviousPage: () => void;
+    goNextPage: (payload?: {}) => void;
+    goToPage: (payload?: {}) => void;
+    compileControls: () => {
+        currentErrors: Record<string, import("./type").LunaticError[]> | undefined;
+        isCritical: boolean;
+    };
+    pageTag: string;
+    isFirstPage: boolean;
+    isLastPage: boolean;
+    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;
+    getData: (withRefreshedCalculated: boolean) => {
+        CALCULATED: {};
+        EXTERNAL: ({
+            variableType: "EXTERNAL";
+            name: string;
+            value: unknown;
+        } & {
+            variableType: "EXTERNAL";
+        })[];
+        COLLECTED: ({
+            variableType: "COLLECTED";
+            name: string;
+            values: import("./type-source").ValuesType<unknown> | import("./type-source").ValuesTypeArray<unknown>;
+        } & {
+            variableType: "COLLECTED";
+        })[];
+    };
+    Provider: FunctionComponent<{
+        children?: import("react").ReactNode;
+    }>;
+    overview: {
+        lunaticId: string;
+        page: string;
+        type: string;
+        label: string;
+        visible: boolean;
+        reached: boolean;
+        children: import("./commons/getOverview").OverviewItem[];
+    }[];
+    loopVariables: string[];
+};
+export default useLunatic;

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

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

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

@@ -0,0 +1,19 @@
+import { SuggesterType } from './type-source';
+type useSuggestersType = {
+    auto: boolean;
+    getReferentiel?: (name: string) => Promise<Array<unknown>>;
+    suggesters?: Array<SuggesterType>;
+};
+export declare enum SuggesterStatus {
+    unused = 0,
+    idle = 1,
+    pending = 2,
+    success = 3,
+    unknown = 4,
+    error = 5
+}
+export declare function useSuggesters({ auto, getReferentiel, suggesters, }: useSuggestersType): (name: string) => {
+    status: SuggesterStatus;
+    timestamp: number;
+};
+export {};

package/lib/src/utils/constants/features.d.ts

@@ -0,0 +1,3 @@
+export declare const VTL: "VTL";
+export declare const MD: "MD";
+export declare const VTL_MD: "VTL|MD";

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

@@ -0,0 +1,5 @@
+export * from './missing';
+export * from './features';
+export * from './links';
+export * from './variable-status';
+export * from './variable-types';

package/lib/src/utils/constants/links.d.ts

@@ -0,0 +1,2 @@
+export declare const X_AXIS = "xAxis";
+export declare const Y_AXIS = "yAxis";

package/lib/src/utils/constants/missing.d.ts

@@ -0,0 +1,2 @@
+export declare const DK: "DK";
+export declare const RF: "RF";

package/lib/src/utils/constants/variable-status.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/utils/constants/variable-types.d.ts

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

package/lib/src/utils/idb-tools/clear-store.d.ts

@@ -0,0 +1,2 @@
+declare function clearStore(db: IDBDatabase, name: string): Promise<boolean>;
+export default clearStore;

package/lib/src/utils/idb-tools/get-idb.d.ts

@@ -0,0 +1,2 @@
+declare function getIDB(): IDBFactory;
+export default getIDB;

package/lib/src/utils/idb-tools/insert-entity.d.ts

@@ -0,0 +1,2 @@
+declare function insert<T>(db: IDBDatabase, storeName: string, entity: T): Promise<boolean>;
+export default insert;

package/lib/src/utils/is-element.d.ts

@@ -0,0 +1,3 @@
+import { ReactElement } from 'react';
+declare function isElement<P = unknown>(element: unknown): element is ReactElement<P>;
+export { isElement };

package/lib/src/utils/is-object.d.ts

@@ -0,0 +1,4 @@
+/**
+ * isObject function with type narrowing
+ */
+export declare function isObject(v: unknown): v is Record<string, unknown>;

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

@@ -0,0 +1,4 @@
+/**
+ * Array.map() but for objet
+ */
+export declare function objectMap<T extends Record<string, any>, V extends unknown>(object: T, callback: (k: keyof T, v: T[keyof T]) => [k: keyof T, v: V] | null): Record<keyof T, V>;

package/lib/src/utils/store-tools/constantes.d.ts

@@ -0,0 +1,21 @@
+export declare const STORE_DATA_NAME = "store/entities";
+export declare const STORE_INFO_NAME = "store/info";
+export declare const STORE_INDEX_NAME = "store/entities/index";
+export declare const STORE_INDEX_PATH = "searching";
+export declare const MAX_STRING: string;
+export declare const SEARCH_TYPES: {
+    prefix: string;
+    tokens: string;
+};
+declare const CONSTANTES: {
+    STORE_DATA_NAME: string;
+    STORE_INDEX_NAME: string;
+    STORE_INDEX_PATH: string;
+    MAX_STRING: string;
+    SEARCH_TYPES: {
+        prefix: string;
+        tokens: string;
+    };
+    STORE_INFO_NAME: string;
+};
+export default CONSTANTES;

package/lib/src/utils/store-tools/initStore.d.ts

@@ -0,0 +1,2 @@
+import { SuggesterType } from '../../use-lunatic/type-source';
+export declare function initStore(storeInfo: SuggesterType): Promise<boolean>;

package/lib/src/utils/store-tools/open-or-create-store.d.ts

@@ -0,0 +1,2 @@
+declare function openStorage(name: string, idbVersion?: number): Promise<IDBDatabase>;
+export default openStorage;

package/lib/src/utils/suggester-workers/append-to-index/create-append-task.d.ts

@@ -0,0 +1,7 @@
+import { SuggesterType } from '../../../use-lunatic/type-source';
+declare function consoleLogging(...args: Array<any>): void;
+/**
+ * Only with Worker
+ */
+export declare function createAppendTask<T>(info: SuggesterType, version: number, log?: typeof consoleLogging): [(args: Array<any>) => Promise<boolean>, () => void];
+export {};

package/lib/src/utils/suggester-workers/create-worker-ts.d.ts

@@ -0,0 +1 @@
+export declare const createWorker: (workerUrl: string) => Worker | null;

package/lib/src/utils/to-number.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Convert an unknown value into a number
+ */
+export declare function toNumber(v: unknown): number | null;

package/lib/src/utils/vtl/dataset-builder.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Convert the value into something compatible with VTL
+ */
+declare function getVtlCompatibleValue(value: unknown): {} | null;
+export default getVtlCompatibleValue;

package/lib/src/utils/vtl/index.d.ts

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