@inseefr/lunatic 2.4.2 → 2.4.3-beta

package/lib/src/components/suggester/searching/index.d.ts

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

package/lib/src/components/suggester-loader-widget/index.d.ts

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

package/lib/src/components/suggester-loader-widget/loader-row.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { SuggesterType } from '../../use-lunatic/type-source';
+type Props = {
+    storeInfo: SuggesterType;
+    idbVersion: number;
+    fetchStore: () => Promise<unknown[]>;
+    disabled?: boolean;
+    onRefresh: (s: string) => void;
+};
+declare function LoaderRow({ storeInfo, idbVersion, fetchStore, onRefresh, disabled, }: Props): JSX.Element;
+export default LoaderRow;

package/lib/src/components/suggester-loader-widget/loader.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { SuggesterType } from '../../use-lunatic/type-source';
+type Props = {
+    idbVersion?: number;
+    db?: IDBDatabase;
+    post?: (name: string, length: number) => void;
+    fetch: () => Promise<unknown[]>;
+    handleClick: (n: number) => void;
+    start?: boolean;
+    store: SuggesterType;
+};
+declare function Loader({ start, db, store, idbVersion, fetch, post, handleClick, }: Props): JSX.Element;
+export default Loader;

package/lib/src/components/suggester-loader-widget/progress.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+type Props = {
+    display?: boolean;
+    percent?: number;
+    handleClick?: (v: number) => void;
+};
+declare function Progress({ display, percent, handleClick }: Props): JSX.Element | null;
+export default Progress;

package/lib/src/components/suggester-loader-widget/tools/action-tool.d.ts

@@ -0,0 +1,9 @@
+import { PropsWithChildren } from 'react';
+type Props = PropsWithChildren<{
+    ariaLabel?: string;
+    className?: string;
+    title?: string;
+    display?: boolean;
+}>;
+declare function ActionTool({ children, ariaLabel, className, title, display, }: Props): JSX.Element | null;
+export default ActionTool;

package/lib/src/components/suggester-loader-widget/tools/index.d.ts

@@ -0,0 +1,2 @@
+export { default as ActionTool } from './action-tool';
+export { default as Tools } from './tools';

package/lib/src/components/suggester-loader-widget/tools/tools.d.ts

@@ -0,0 +1,3 @@
+import { PropsWithChildren } from 'react';
+declare function Tools({ children }: PropsWithChildren): JSX.Element;
+export default Tools;

package/lib/src/components/suggester-loader-widget/widget-container.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+declare const _default: React.ForwardRefExoticComponent<{
+    drag?: boolean | undefined;
+    absolute?: boolean | undefined;
+} & {
+    children?: React.ReactNode;
+} & React.RefAttributes<HTMLDivElement>>;
+export default _default;

package/lib/src/components/suggester-loader-widget/widget.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+import './widget.scss';
+import { SuggesterType } from '../../use-lunatic/type-source';
+type Props = {
+    absolute?: boolean;
+    source: {
+        suggesters: Array<SuggesterType>;
+    };
+    onRefresh: () => void;
+    getStoreInfo: (s: string) => {
+        idbVersion: number;
+        fetch: () => Promise<unknown[]>;
+    };
+};
+declare function SuggesterLoaderWidget({ source, getStoreInfo, onRefresh, absolute, }: Props): JSX.Element;
+export default SuggesterLoaderWidget;

package/lib/src/components/switch/html/switch.d.ts

@@ -0,0 +1,17 @@
+import React, { ReactNode } from 'react';
+import './switch.scss';
+import { LunaticError } from '../../../use-lunatic/type';
+type Props = {
+    checked?: boolean;
+    disabled?: boolean;
+    statusLabel: {
+        true: ReactNode;
+        false: ReactNode;
+    };
+    onClick: (v: boolean) => void;
+    id: string;
+    label: ReactNode;
+    errors?: Record<string, LunaticError[]>;
+};
+declare const _default: React.ComponentType<Props>;
+export default _default;

package/lib/src/components/switch/index.d.ts

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

package/lib/src/components/switch/lunatic-switch.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { LunaticComponentProps } from '../type';
+declare function LunaticSwitch({ id, value, statusLabel, handleChange, response, preferences, declarations, missing, missingResponse, management, description, label, errors, }: LunaticComponentProps<'Switch'>): JSX.Element;
+export default LunaticSwitch;

package/lib/src/components/table/cell.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="react" />
+import { LunaticBaseProps } from '../type';
+import type { LunaticComponentDefinition, LunaticExpression } from '../../use-lunatic/type';
+type Props = {
+    content: LunaticComponentDefinition | {
+        label: LunaticExpression;
+        rowspan?: number;
+        colspan?: number;
+    };
+    id: string;
+    executeExpression: LunaticBaseProps['executeExpression'];
+    iteration?: number;
+    value: Record<string, unknown>;
+    row?: string | number;
+    index?: string | number;
+    handleChange: LunaticBaseProps['handleChange'];
+    errors: LunaticBaseProps['errors'];
+};
+declare function Cell({ content, id, executeExpression, iteration, value, row, index, handleChange, errors, }: Props): JSX.Element;
+export default Cell;

package/lib/src/components/table/header.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+type Props = {
+    id?: string;
+    header?: Array<{
+        label?: ReactNode;
+        colspan?: number;
+        rowspan?: number;
+    }>;
+};
+declare function Header({ id, header }: Props): JSX.Element | null;
+export default Header;

package/lib/src/components/table/index.d.ts

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

package/lib/src/components/table/lunatic-table.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { LunaticComponentProps } from '../type';
+declare function LunaticTable(props: LunaticComponentProps<'Table'>): JSX.Element;
+export default LunaticTable;

package/lib/src/components/table/row.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import type { LunaticComponentDefinition, LunaticExpression } from '../../use-lunatic/type';
+import { LunaticBaseProps } from '../type';
+type Props = {
+    components: Array<LunaticComponentDefinition | {
+        label: LunaticExpression;
+        rowspan?: number;
+        colspan?: number;
+    }>;
+    id: string;
+    executeExpression: LunaticBaseProps['executeExpression'];
+    iteration?: number;
+    valueMap: Record<string, unknown>;
+    rowIndex?: string | number;
+    handleChange: LunaticBaseProps['handleChange'];
+    errors: LunaticBaseProps['errors'];
+};
+declare function Row({ id, components, executeExpression, valueMap, rowIndex, iteration, handleChange, errors, }: Props): JSX.Element;
+export default Row;

package/lib/src/components/table/table-orchestrator.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { LunaticComponentProps } from '../type';
+type Props = {} & Pick<LunaticComponentProps<'Table'>, 'body' | 'id' | 'executeExpression' | 'value' | 'handleChange' | 'iteration' | 'errors'>;
+declare function TableOrchestrator({ body, id, executeExpression, value: valueMap, handleChange, iteration, errors, }: Props): JSX.Element | null;
+export default TableOrchestrator;

package/lib/src/components/textarea/html/textarea.d.ts

@@ -0,0 +1,17 @@
+import React, { ReactNode } from 'react';
+import './textarea.scss';
+import { LunaticBaseProps } from '../../type';
+type Props = {
+    id?: string;
+    rows?: number;
+    maxLength?: number;
+    cols?: number;
+    onChange: (n: string) => void;
+    placeholder?: string;
+    label?: ReactNode;
+    value?: string | number | null;
+    description?: string;
+    errors?: LunaticBaseProps['errors'];
+};
+declare const _default: React.ComponentType<Props>;
+export default _default;

package/lib/src/components/textarea/index.d.ts

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

package/lib/src/components/textarea/lunatic-textarea.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import PropTypes from 'prop-types';
+import { LunaticComponentProps } from '../type';
+declare const LunaticTextarea: {
+    (props: LunaticComponentProps<'Textarea'>): JSX.Element;
+    defaultProps: {
+        rows: number;
+        maxLength: number;
+        cols: number;
+        placeholder: string;
+    };
+    propTypes: {
+        rows: PropTypes.Requireable<number>;
+        maxLength: PropTypes.Requireable<number>;
+        cols: PropTypes.Requireable<number>;
+        placeholder: PropTypes.Requireable<string>;
+    };
+};
+export default LunaticTextarea;

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

@@ -1,22 +1,29 @@
-import { CSSProperties, FunctionComponent, ReactNode } from 'react';
 import { LunaticComponentDefinition, LunaticError, LunaticExpression, LunaticState } from '../use-lunatic/type';
-type SharedProps<ValueType> = {
+import { CSSProperties, FunctionComponent, ReactNode } from 'react';
+import { SuggesterStatus } from '../use-lunatic/use-suggesters';
+import useLunatic from '../use-lunatic';
+export type LunaticBaseProps<ValueType = unknown> = {
     id: string;
     handleChange: (response: {
         name: string;
-    }, value: ValueType, args: Record<string, unknown>) => void;
-    errors?: Record<string, LunaticError[]>;
-    preferences: LunaticState['preferences'];
+    }, value: ValueType, args?: Record<string, unknown>) => void;
+    errors?: {
+        [id: string]: LunaticError[];
+    };
+    preferences?: LunaticState['preferences'];
     declarations?: {
         id: string;
         declarationType: string;
         position: string;
         label: ReactNode;
     }[];
-    label: ReactNode;
+    label?: ReactNode;
     disabled?: boolean;
     missing?: unknown;
-    missingResponse?: unknown;
+    missingResponse?: {
+        name: string;
+        value?: unknown;
+    };
     management?: LunaticState['management'];
     description?: ReactNode;
     shortcut?: boolean;
@@ -25,11 +32,17 @@ type SharedProps<ValueType> = {
     readOnly?: boolean;
     className?: string;
     style?: CSSProperties;
+    iteration?: number;
+    executeExpression: LunaticState['executeExpression'];
+    features?: string[];
+    componentType?: string;
 };
-type SuggesterOption = {
+export type SuggesterOption = {
     children?: string[];
-    id: string;
-    label: string;
+    id?: string;
+    description?: ReactNode;
+    label?: ReactNode;
+    value: string;
     niveau?: string;
     parent?: string;
     tokensMap?: Record<string, {
@@ -38,7 +51,7 @@ type SuggesterOption = {
     }>;
 };
 type ComponentPropsByType = {
-    InputNumber: SharedProps<number> & {
+    InputNumber: LunaticBaseProps<number | null> & {
         min: number;
         max: number;
         decimals: number;
@@ -47,16 +60,20 @@ type ComponentPropsByType = {
             name: string;
         };
     };
-    Input: SharedProps<string> & {
+    Input: LunaticBaseProps<string> & {
         maxLength?: number;
         value: null | string;
         response: {
             name: string;
         };
     };
-    Sequence: Pick<SharedProps<string>, 'id' | 'declarations' | 'label' | 'style'>;
-    Subsequence: Pick<SharedProps<string>, 'id' | 'declarations' | 'label'>;
-    RosterForLoop: SharedProps<unknown> & {
+    Sequence: Pick<LunaticBaseProps<string>, 'id' | 'declarations' | 'label' | 'style'>;
+    Subsequence: Pick<LunaticBaseProps<string>, 'id' | 'declarations' | 'label'>;
+    ComponentSet: LunaticBaseProps<unknown> & {
+        components: LunaticComponentDefinition[];
+        value: Record<string, unknown>;
+    };
+    RosterForLoop: LunaticBaseProps<unknown> & {
         lines: {
             min: number;
             max: number;
@@ -65,13 +82,12 @@ type ComponentPropsByType = {
         components: LunaticComponentDefinition[];
         executeExpression: LunaticState['executeExpression'];
         value: Record<string, unknown[]>;
-        componentType: 'RosterForLoop';
         headers?: Array<{
-            label: LunaticExpression;
+            label: ReactNode;
         }>;
         paginatedLoop?: boolean;
     };
-    Loop: SharedProps<unknown> & {
+    Loop: LunaticBaseProps<unknown> & {
         lines: {
             min: number;
             max: number;
@@ -80,15 +96,17 @@ type ComponentPropsByType = {
         components: LunaticComponentDefinition[];
         executeExpression: LunaticState['executeExpression'];
         value: Record<string, unknown[]>;
-        componentType: 'Loop';
         headers?: Array<{
-            label: LunaticExpression;
+            label: ReactNode;
         }>;
         paginatedLoop?: boolean;
     };
-    Table: SharedProps<unknown> & {
+    Table: LunaticBaseProps<unknown> & {
+        value: Record<string, unknown>;
         header: Array<{
-            label: LunaticExpression;
+            label: ReactNode;
+            rowspan?: number;
+            colspan?: number;
         }>;
         body: Array<Array<{
             label: LunaticExpression;
@@ -96,24 +114,27 @@ type ComponentPropsByType = {
         executeExpression: LunaticState['executeExpression'];
         iteration: LunaticState['pager']['iteration'];
     };
-    Datepicker: SharedProps<string> & {
+    Datepicker: LunaticBaseProps<string | null> & {
         min?: string;
         max?: string;
-        value: null | string;
         response: {
             name: string;
         };
     };
-    CheckboxGroup: SharedProps<Record<string, boolean | null>> & {
+    CheckboxGroup: LunaticBaseProps<Record<string, boolean | null>> & {
         responses: Array<{
             id: string;
             label: ReactNode;
+            description?: ReactNode;
             response: {
                 name: string;
             };
         }>;
+        handleChange: (response: {
+            name: string;
+        }, value: boolean, args?: Record<string, unknown>) => void;
     };
-    CheckboxOne: SharedProps<string> & {
+    CheckboxOne: LunaticBaseProps<string | null> & {
         options: Array<{
             description: ReactNode;
             label: ReactNode;
@@ -123,7 +144,16 @@ type ComponentPropsByType = {
             name: string;
         };
     };
-    CheckboxBoolean: SharedProps<string> & {
+    Switch: LunaticBaseProps<boolean> & {
+        response: {
+            name: string;
+        };
+        statusLabel?: {
+            true: string;
+            false: string;
+        };
+    };
+    CheckboxBoolean: LunaticBaseProps<boolean> & {
         options: Array<{
             description: ReactNode;
             label: ReactNode;
@@ -133,7 +163,7 @@ type ComponentPropsByType = {
             name: string;
         };
     };
-    Radio: SharedProps<string> & {
+    Radio: LunaticBaseProps<string | null> & {
         options: Array<{
             description: ReactNode;
             label: ReactNode;
@@ -144,7 +174,19 @@ type ComponentPropsByType = {
             name: string;
         };
     };
-    Dropdown: SharedProps<string> & {
+    Roundabout: LunaticBaseProps<string> & {
+        iterations: number;
+        goToPage: ReturnType<typeof useLunatic>['goToPage'];
+        page: string;
+        locked?: boolean;
+        expressions: {
+            unnecessary?: Array<boolean>;
+            complete?: Array<boolean>;
+            partial?: Array<boolean>;
+            label?: Array<string>;
+        };
+    };
+    Dropdown: LunaticBaseProps<string | null> & {
         options: Array<{
             description: ReactNode;
             label: ReactNode;
@@ -153,17 +195,19 @@ type ComponentPropsByType = {
         response: {
             name: string;
         };
+        writable?: boolean;
     };
-    Textarea: SharedProps<string> & {
+    Textarea: LunaticBaseProps<string> & {
         cols?: number;
+        placeHolder?: string;
         maxLength?: number;
         rows?: number;
         response: {
             name: string;
         };
     };
-    FilterDescription: Pick<SharedProps<string>, 'id' | 'label'>;
-    PairwiseLinks: SharedProps<string> & {
+    FilterDescription: Pick<LunaticBaseProps<string>, 'id' | 'label'>;
+    PairwiseLinks: Omit<LunaticBaseProps, 'value'> & {
         components: LunaticComponentDefinition[];
         features?: LunaticState['features'];
         executeExpression: LunaticState['executeExpression'];
@@ -172,15 +216,19 @@ type ComponentPropsByType = {
         symLinks: Record<string, Record<string, string>>;
         value: Record<string, unknown[]>;
     };
-    Suggester: SharedProps<string> & {
+    Suggester: LunaticBaseProps<string | null> & {
         storeName: string;
-        optionRendered: FunctionComponent<{
+        getSuggesterStatus: (name: string) => {
+            status: SuggesterStatus;
+            timestamp: number;
+        };
+        optionRenderer: FunctionComponent<{
             option: SuggesterOption;
             placeholder?: string;
             search?: string;
         }>;
         labelRenderer: FunctionComponent<{
-            option: SuggesterOption;
+            option?: SuggesterOption;
             selected?: boolean;
             search?: string;
         }>;
@@ -191,5 +239,6 @@ type ComponentPropsByType = {
         };
     };
 };
-export type ComponentProps<T extends keyof ComponentPropsByType> = ComponentPropsByType[T];
+export type LunaticComponentType = keyof ComponentPropsByType;
+export type LunaticComponentProps<T extends LunaticComponentType = LunaticComponentType> = ComponentPropsByType[T];
 export {};

package/lib/src/hooks/use-ref-sync.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+/**
+ * useRef, but keep the value in sync on every render
+ */
+export declare function useRefSync<T extends unknown>(value: T): import("react").MutableRefObject<T>;

package/lib/src/index.d.ts

@@ -1,3 +1,4 @@
 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';
+export type { LunaticComponentProps } from './components/type';

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

@@ -1 +1,5 @@
 export type Overwrite<T, U> = Omit<T, keyof U> & U;
+type Defined<T> = T extends undefined | infer V ? V : T;
+export type ItemOf<ArrayType> = Defined<ArrayType> extends (infer ElementType)[] ? ElementType : never;
+export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+export {};

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

@@ -5,5 +5,8 @@ export type DeepTranslateExpression<T> = T extends LunaticExpression ? ReactNode
 } ? {
     [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" | "ComponentSet" | "Roundabout">;
+declare function fillComponentExpressions(component: LunaticComponentDefinition, state: {
+    executeExpression: LunaticState['executeExpression'];
+    pager: Pick<LunaticState['pager'], 'iteration' | 'linksIterations'>;
+}): LunaticComponentDefinition;
 export default fillComponentExpressions;