@legalplace/wizardx-core 4.42.10-nightly.20251125120616 → 4.42.11

package/dist/componentsConnectors/connectProgress.d.ts

@@ -1,7 +1,7 @@
-export type ConnectPreviewOwnProps = {
+export declare type ConnectPreviewOwnProps = {
     id?: number;
 };
-export type ConnectPreviewMapProps = {
+export declare type ConnectPreviewMapProps = {
     currentSectionTitle: string;
     currentSectionId: number;
     currentSection: number;
@@ -10,5 +10,7 @@ export type ConnectPreviewMapProps = {
     totalPages: number;
 };
 export declare const connectProgress: <AdditionnalProps = {}>(Component: import("react").ComponentType<ConnectPreviewOwnProps & ConnectPreviewMapProps & AdditionnalProps>, connectorOptions?: {
-    memoizeStateToProps?: boolean;
-} | undefined) => any;
+    memoizeStateToProps?: boolean | undefined;
+} | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & ConnectPreviewOwnProps & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;

package/dist/componentsConnectors/connectRootOption.d.ts

@@ -1,8 +1,8 @@
 import type { OptionV3 } from "@legalplace/models-v3-types";
-export type ConnectRootOptionOwnProps = {
+export declare type ConnectRootOptionOwnProps = {
     id: number;
 };
-export type ConnectRootOptionMapProps = {
+export declare type ConnectRootOptionMapProps = {
     id: number;
     multiple: boolean;
     values: boolean[];
@@ -11,10 +11,12 @@ export type ConnectRootOptionMapProps = {
     lastIndex: number;
     meta: OptionV3["meta"];
 };
-export type ConnectRootOptionDispatchProps = {
+export declare type ConnectRootOptionDispatchProps = {
     addMultipleOccurency: () => void;
     deleteMultipleOccurency: (index: number) => void;
 };
 export declare const connectRootOption: <AdditionnalProps = {}>(Component: import("react").ComponentType<ConnectRootOptionOwnProps & ConnectRootOptionMapProps & ConnectRootOptionDispatchProps & AdditionnalProps>, connectorOptions?: {
-    memoizeStateToProps?: boolean;
-} | undefined) => any;
+    memoizeStateToProps?: boolean | undefined;
+} | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & ConnectRootOptionOwnProps & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;

package/dist/componentsConnectors/connectSection.d.ts

@@ -1,7 +1,7 @@
-export type ConnectSectionOwnProps = {
+export declare type ConnectSectionOwnProps = {
     id?: number;
 };
-export type ConnectSectionMapProps = {
+export declare type ConnectSectionMapProps = {
     id: number;
     title: string;
     mandatoryValidated: boolean;
@@ -9,5 +9,7 @@ export type ConnectSectionMapProps = {
     tags?: string[];
 };
 export declare const connectSection: <AdditionnalProps = {}>(Component: import("react").ComponentType<ConnectSectionOwnProps & ConnectSectionMapProps & AdditionnalProps>, connectorOptions?: {
-    memoizeStateToProps?: boolean;
-} | undefined) => any;
+    memoizeStateToProps?: boolean | undefined;
+} | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & ConnectSectionOwnProps & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;

package/dist/componentsConnectors/connectSummary.d.ts

@@ -1,9 +1,13 @@
-export type ConnectSummaryOwnProps = {};
-export type ConnectSummaryMapProps = {
+export declare type ConnectSummaryOwnProps = {};
+export declare type ConnectSummaryMapProps = {
     sections: Readonly<number[]>;
 };
 export declare const connectSummary: <AdditionnalProps = {}>(Component: import("react").ComponentType<{
-    store?: import("redux").Store;
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
 } & ConnectSummaryMapProps & AdditionnalProps>, connectorOptions?: {
-    memoizeStateToProps?: boolean;
-} | undefined) => any;
+    memoizeStateToProps?: boolean | undefined;
+} | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+} & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;

package/dist/componentsConnectors/connectSummaryItem.d.ts

@@ -1,7 +1,7 @@
-export type ConnectSummaryItemOwnProps = {
+export declare type ConnectSummaryItemOwnProps = {
     id: number;
 };
-export type ConnectSummaryItemMapProps = {
+export declare type ConnectSummaryItemMapProps = {
     link: string;
     label: string;
     validity: boolean;
@@ -11,5 +11,7 @@ export type ConnectSummaryItemMapProps = {
     disableClick?: boolean;
 };
 export declare const connectSummaryItem: <AdditionnalProps = {}>(Component: import("react").ComponentType<ConnectSummaryItemOwnProps & ConnectSummaryItemMapProps & AdditionnalProps>, connectorOptions?: {
-    memoizeStateToProps?: boolean;
-} | undefined) => any;
+    memoizeStateToProps?: boolean | undefined;
+} | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & ConnectSummaryItemOwnProps & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;

package/dist/componentsConnectors/connectTermsheet.js

@@ -176,7 +176,7 @@ const TermsheetHooc = (Component) => (props) => {
     const afterAnchors = ["afterTermsheet"];
     const replaceAnchors = ["Termsheet"];
     const FinalComponent = replaceComponent(replaceAnchors, Component);
-    return (_jsxs(_Fragment, { children: [_jsx(PluginLoader, { anchor: beforeAnchors, props: props }), _jsx(FinalComponent, Object.assign({}, props)), _jsx(PluginLoader, { anchor: afterAnchors, props: props })] }));
+    return (_jsxs(_Fragment, { children: [_jsx(PluginLoader, { anchor: beforeAnchors, props: props }, void 0), _jsx(FinalComponent, Object.assign({}, props), void 0), _jsx(PluginLoader, { anchor: afterAnchors, props: props }, void 0)] }, void 0));
 };
 const mapStateToProps = (state) => {
     const pathReader = new PathReader(state);

package/dist/componentsConnectors/connectVariable.d.ts

@@ -1,15 +1,15 @@
 import type { AutocompleteDatasetType, VariableV3 } from "@legalplace/models-v3-types";
 import type { ConnectorMapSelectors } from "./connector/componentConnector";
-export type ConnectVariableOwnProps = {
+export declare type ConnectVariableOwnProps = {
     id: number;
     index: number;
 };
-type AutocompleteParent = {
+declare type AutocompleteParent = {
     id?: number;
     condition?: boolean;
     value?: string | number;
 };
-export type ConnectVariableMapProps = {
+export declare type ConnectVariableMapProps = {
     id: number;
     index: number;
     label: string;
@@ -28,11 +28,13 @@ export type ConnectVariableMapProps = {
     meta: VariableV3;
     autocompleteParents?: AutocompleteParent[];
 };
-export type ConnectVariableDispatchProps = {
+export declare type ConnectVariableDispatchProps = {
     updateVariable: (value: string | number) => void;
 };
 export declare const canVariableDisplay: (id: number, index: number, selectors: ConnectorMapSelectors) => Readonly<boolean>;
 export declare const connectVariable: <AdditionnalProps = {}>(Component: import("react").ComponentType<ConnectVariableOwnProps & ConnectVariableMapProps & ConnectVariableDispatchProps & AdditionnalProps>, connectorOptions?: {
-    memoizeStateToProps?: boolean;
-} | undefined) => any;
+    memoizeStateToProps?: boolean | undefined;
+} | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & ConnectVariableOwnProps & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;
 export {};

package/dist/componentsConnectors/connectWizardWrapper.d.ts

@@ -1,8 +1,10 @@
-export type ConnectWizardWrapperDispatchProps = {
+export declare type ConnectWizardWrapperDispatchProps = {
     openPreview: () => void;
     closePreview: () => void;
 };
-export type ConnectWizardWrapperOwnProps = {};
+export declare type ConnectWizardWrapperOwnProps = {};
 export declare const connectWizardWrapper: <AdditionnalProps = {}>(Component: import("react").ComponentType<ConnectWizardWrapperDispatchProps & AdditionnalProps>, connectorOptions?: {
-    memoizeStateToProps?: boolean;
-} | undefined) => any;
+    memoizeStateToProps?: boolean | undefined;
+} | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & AdditionnalProps & {
+    store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+}>;

package/dist/componentsConnectors/connector/componentConnector.d.ts

@@ -1,17 +1,18 @@
 import type { Dispatch, Store } from "redux";
 import type { ComponentType } from "react";
+import React from "react";
 import type { StateType } from "../../types/State.type";
 import type { SelectorsLibraryType } from "../../types/getSelectors.type";
 import type { ActionsLibraryType } from "../../types/getActions.type";
-export type AdditionnalHooksFunction<P> = (props: P, hookType: string) => string[];
-export type ConnectorDispatchProps<OwnProps, DispatchProps, OwnPropsWithStore = OwnProps & {
+export declare type AdditionnalHooksFunction<P> = (props: P, hookType: string) => string[];
+export declare type ConnectorDispatchProps<OwnProps, DispatchProps, OwnPropsWithStore = OwnProps & {
     store?: Store;
 }> = (actions: Readonly<ActionsLibraryType>, selectors: Readonly<SelectorsLibraryType>) => (dispatch: Dispatch, ownProps: OwnPropsWithStore) => DispatchProps;
-export type ConnectorStateToProps<OwnProps, MapProps, OwnPropsWithStore = OwnProps & {
+export declare type ConnectorStateToProps<OwnProps, MapProps, OwnPropsWithStore = OwnProps & {
     store?: Store;
 }> = ((selectors: Readonly<SelectorsLibraryType>) => (state: StateType, ownProps: OwnPropsWithStore) => MapProps) | undefined;
-export type ConnectorAdditionnalHooks<InjectedProps> = (props: InjectedProps, hookType: string) => string[];
-export type ConnectorMapSelectors = SelectorsLibraryType;
+export declare type ConnectorAdditionnalHooks<InjectedProps> = (props: InjectedProps, hookType: string) => string[];
+export declare type ConnectorMapSelectors = SelectorsLibraryType;
 export declare function componentConnector<OwnProps = {}, MapProps = {}, DispatchProps = {}, OwnPropsWithStore = OwnProps & {
     store?: Store;
 }, InjectedProps = OwnPropsWithStore & MapProps & DispatchProps>(options: {
@@ -22,5 +23,7 @@ export declare function componentConnector<OwnProps = {}, MapProps = {}, Dispatc
     dispatchToProps?: ConnectorDispatchProps<OwnPropsWithStore, DispatchProps> | undefined;
     additionnalHooks?: AdditionnalHooksFunction<InjectedProps>;
 }): <AdditionnalProps = {}>(Component: ComponentType<InjectedProps & AdditionnalProps>, connectorOptions?: {
-    memoizeStateToProps?: boolean;
-}) => any;
+    memoizeStateToProps?: boolean | undefined;
+} | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<React.ComponentClass<any, any> | React.FunctionComponent<any>, import("react-redux").Omit<any, never> & OwnPropsWithStore & AdditionnalProps & {
+    store?: Store<any, import("redux").AnyAction> | undefined;
+}>;

package/dist/componentsConnectors/connector/componentConnector.js

@@ -22,7 +22,7 @@ const AnchorsHooks = (props, componentName, additionnalHooks) => {
     };
 };
 const PluginWrapper = (props, anchors) => {
-    const WrappedPlugin = () => _jsx(PluginLoader, { anchor: anchors, props: props });
+    const WrappedPlugin = () => _jsx(PluginLoader, { anchor: anchors, props: props }, void 0);
     WrappedPlugin.displayName = `Plugin(${anchors
         .join(", ")
         .replace(/\(/g, "[")
@@ -35,7 +35,7 @@ const ConnectorHooc = (Component, componentName, additionnalHooks) => {
         const FinalComponent = replaceComponent(replaceAnchors, Component, componentName);
         const BeforePlugings = PluginWrapper(props, beforeAnchors);
         const AfterPlugings = PluginWrapper(props, afterAnchors);
-        return (_jsxs(_Fragment, { children: [_jsx(BeforePlugings, {}), _jsx(FinalComponent, Object.assign({}, props)), _jsx(AfterPlugings, {})] }));
+        return (_jsxs(_Fragment, { children: [_jsx(BeforePlugings, {}, void 0), _jsx(FinalComponent, Object.assign({}, props), void 0), _jsx(AfterPlugings, {}, void 0)] }, void 0));
     };
     ConnectedComponent.displayName = `connectedComponent(${componentName})`;
     return ConnectedComponent;
@@ -80,7 +80,7 @@ function ConnectorConnectWithStore(options) {
     const { stateToProps, dispatchToProps } = options;
     return (Component) => {
         const ConnectedWrappedComponent = ConnectorConnect({ stateToProps, dispatchToProps })(Component);
-        return (props) => (_jsx(ConnectedWrappedComponent, Object.assign({}, props, { store: getStore() })));
+        return (props) => (_jsx(ConnectedWrappedComponent, Object.assign({}, props, { store: getStore() }), void 0));
     };
 }
 export function componentConnector(options) {

package/dist/componentsConnectors/library.d.ts

@@ -1,55 +1,89 @@
 import { componentConnector } from "./connector/componentConnector";
 export declare const connectorsLibrary: {
     connectBox: <AdditionnalProps = {}>(Component: import("react").ComponentType<import("./connectBox").ConnectBoxOwnProps & import("./connectBox").ConnectBoxMapProps & AdditionnalProps>, connectorOptions?: {
-        memoizeStateToProps?: boolean;
-    } | undefined) => any;
-    connectDocument: <AdditionnalProps = {}>(Component: import("react").ComponentType<import("./connectDocument").ConnectDocumentOwnProps & import("./connectDocument").ConnectDocumentMapProps & AdditionnalProps>, connectorOptions?: {
-        memoizeStateToProps?: boolean;
-    } | undefined) => any;
-    connectHeader: <AdditionnalProps = {}>(Component: import("react").ComponentType<import("./connectHeader").ConnectHeaderOwnProps & import("./connectHeader").ConnectHeaderMapProps & AdditionnalProps>, connectorOptions?: {
-        memoizeStateToProps?: boolean;
-    } | undefined) => any;
-    connectMetaTitle: <AdditionnalProps = {}>(Component: import("react").ComponentType<{
-        store?: import("redux").Store;
+        memoizeStateToProps?: boolean | undefined;
+    } | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & import("./connectBox").ConnectBoxOwnProps & AdditionnalProps & {
+        store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+    }>;
+    connectDocument: <AdditionnalProps_1 = {}>(Component: import("react").ComponentType<import("./connectDocument").ConnectDocumentOwnProps & import("./connectDocument").ConnectDocumentMapProps & AdditionnalProps_1>, connectorOptions?: {
+        memoizeStateToProps?: boolean | undefined;
+    } | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & import("./connectDocument").ConnectDocumentOwnProps & AdditionnalProps_1 & {
+        store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+    }>;
+    connectHeader: <AdditionnalProps_2 = {}>(Component: import("react").ComponentType<import("./connectHeader").ConnectHeaderOwnProps & import("./connectHeader").ConnectHeaderMapProps & AdditionnalProps_2>, connectorOptions?: {
+        memoizeStateToProps?: boolean | undefined;
+    } | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & import("./connectHeader").ConnectHeaderOwnProps & AdditionnalProps_2 & {
+        store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+    }>;
+    connectMetaTitle: <AdditionnalProps_3 = {}>(Component: import("react").ComponentType<{
+        store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
     } & {
         title: string;
-    } & AdditionnalProps>, connectorOptions?: {
-        memoizeStateToProps?: boolean;
-    } | undefined) => any;
-    connectOption: <AdditionnalProps = {}>(Component: import("react").ComponentType<import("./connectOption").ConnectOptionOwnProps & import("./connectOption").ConnectOptionMapProps & import("./connectOption").ConnectOptionDispatchProps & AdditionnalProps>, connectorOptions?: {
-        memoizeStateToProps?: boolean;
-    } | undefined) => any;
-    connectPagination: <AdditionnalProps = {}>(Component: import("react").ComponentType<import("./connectPagination").ConnectPaginationMapProps & import("./connectPagination").ConnectPaginationDispatchProps & AdditionnalProps>, connectorOptions?: {
-        memoizeStateToProps?: boolean;
-    } | undefined) => any;
-    connectPreview: <AdditionnalProps = {}>(Component: import("react").ComponentType<{
-        store?: import("redux").Store;
-    } & AdditionnalProps>, connectorOptions?: {
-        memoizeStateToProps?: boolean;
-    } | undefined) => any;
-    connectProgress: <AdditionnalProps = {}>(Component: import("react").ComponentType<import("./connectProgress").ConnectPreviewOwnProps & import("./connectProgress").ConnectPreviewMapProps & AdditionnalProps>, connectorOptions?: {
-        memoizeStateToProps?: boolean;
-    } | undefined) => any;
-    connectRootOption: <AdditionnalProps = {}>(Component: import("react").ComponentType<import("./connectRootOption").ConnectRootOptionOwnProps & import("./connectRootOption").ConnectRootOptionMapProps & import("./connectRootOption").ConnectRootOptionDispatchProps & AdditionnalProps>, connectorOptions?: {
-        memoizeStateToProps?: boolean;
-    } | undefined) => any;
-    connectSection: <AdditionnalProps = {}>(Component: import("react").ComponentType<import("./connectSection").ConnectSectionOwnProps & import("./connectSection").ConnectSectionMapProps & AdditionnalProps>, connectorOptions?: {
-        memoizeStateToProps?: boolean;
-    } | undefined) => any;
-    connectSummary: <AdditionnalProps = {}>(Component: import("react").ComponentType<{
-        store?: import("redux").Store;
-    } & import("./connectSummary").ConnectSummaryMapProps & AdditionnalProps>, connectorOptions?: {
-        memoizeStateToProps?: boolean;
-    } | undefined) => any;
-    connectSummaryItem: <AdditionnalProps = {}>(Component: import("react").ComponentType<import("./connectSummaryItem").ConnectSummaryItemOwnProps & import("./connectSummaryItem").ConnectSummaryItemMapProps & AdditionnalProps>, connectorOptions?: {
-        memoizeStateToProps?: boolean;
-    } | undefined) => any;
+    } & AdditionnalProps_3>, connectorOptions?: {
+        memoizeStateToProps?: boolean | undefined;
+    } | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & {
+        store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+    } & AdditionnalProps_3 & {
+        store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+    }>;
+    connectOption: <AdditionnalProps_4 = {}>(Component: import("react").ComponentType<import("./connectOption").ConnectOptionOwnProps & import("./connectOption").ConnectOptionMapProps & import("./connectOption").ConnectOptionDispatchProps & AdditionnalProps_4>, connectorOptions?: {
+        memoizeStateToProps?: boolean | undefined;
+    } | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & import("./connectOption").ConnectOptionOwnProps & AdditionnalProps_4 & {
+        store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+    }>;
+    connectPagination: <AdditionnalProps_5 = {}>(Component: import("react").ComponentType<import("./connectPagination").ConnectPaginationMapProps & import("./connectPagination").ConnectPaginationDispatchProps & AdditionnalProps_5>, connectorOptions?: {
+        memoizeStateToProps?: boolean | undefined;
+    } | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & AdditionnalProps_5 & {
+        store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+    }>;
+    connectPreview: <AdditionnalProps_6 = {}>(Component: import("react").ComponentType<{
+        store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+    } & AdditionnalProps_6>, connectorOptions?: {
+        memoizeStateToProps?: boolean | undefined;
+    } | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & {
+        store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+    } & AdditionnalProps_6 & {
+        store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+    }>;
+    connectProgress: <AdditionnalProps_7 = {}>(Component: import("react").ComponentType<import("./connectProgress").ConnectPreviewOwnProps & import("./connectProgress").ConnectPreviewMapProps & AdditionnalProps_7>, connectorOptions?: {
+        memoizeStateToProps?: boolean | undefined;
+    } | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & import("./connectProgress").ConnectPreviewOwnProps & AdditionnalProps_7 & {
+        store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+    }>;
+    connectRootOption: <AdditionnalProps_8 = {}>(Component: import("react").ComponentType<import("./connectRootOption").ConnectRootOptionOwnProps & import("./connectRootOption").ConnectRootOptionMapProps & import("./connectRootOption").ConnectRootOptionDispatchProps & AdditionnalProps_8>, connectorOptions?: {
+        memoizeStateToProps?: boolean | undefined;
+    } | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & import("./connectRootOption").ConnectRootOptionOwnProps & AdditionnalProps_8 & {
+        store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+    }>;
+    connectSection: <AdditionnalProps_9 = {}>(Component: import("react").ComponentType<import("./connectSection").ConnectSectionOwnProps & import("./connectSection").ConnectSectionMapProps & AdditionnalProps_9>, connectorOptions?: {
+        memoizeStateToProps?: boolean | undefined;
+    } | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & import("./connectSection").ConnectSectionOwnProps & AdditionnalProps_9 & {
+        store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+    }>;
+    connectSummary: <AdditionnalProps_10 = {}>(Component: import("react").ComponentType<{
+        store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+    } & import("./connectSummary").ConnectSummaryMapProps & AdditionnalProps_10>, connectorOptions?: {
+        memoizeStateToProps?: boolean | undefined;
+    } | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & {
+        store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+    } & AdditionnalProps_10 & {
+        store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+    }>;
+    connectSummaryItem: <AdditionnalProps_11 = {}>(Component: import("react").ComponentType<import("./connectSummaryItem").ConnectSummaryItemOwnProps & import("./connectSummaryItem").ConnectSummaryItemMapProps & AdditionnalProps_11>, connectorOptions?: {
+        memoizeStateToProps?: boolean | undefined;
+    } | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & import("./connectSummaryItem").ConnectSummaryItemOwnProps & AdditionnalProps_11 & {
+        store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+    }>;
     connectTermsheet: import("redux").Func1<import("react").ComponentType<import("..").TermsheetPropsType>, import("react-redux").ConnectedComponent<import("react").FC<import("..").TermsheetPropsType>, import("react-redux").Omit<import("..").TermsheetPropsType, "termsheet" | "parseLink">>>;
-    connectVariable: <AdditionnalProps = {}>(Component: import("react").ComponentType<import("./connectVariable").ConnectVariableOwnProps & import("./connectVariable").ConnectVariableMapProps & import("./connectVariable").ConnectVariableDispatchProps & AdditionnalProps>, connectorOptions?: {
-        memoizeStateToProps?: boolean;
-    } | undefined) => any;
-    connectWizardWrapper: <AdditionnalProps = {}>(Component: import("react").ComponentType<import("./connectWizardWrapper").ConnectWizardWrapperDispatchProps & AdditionnalProps>, connectorOptions?: {
-        memoizeStateToProps?: boolean;
-    } | undefined) => any;
+    connectVariable: <AdditionnalProps_12 = {}>(Component: import("react").ComponentType<import("./connectVariable").ConnectVariableOwnProps & import("./connectVariable").ConnectVariableMapProps & import("./connectVariable").ConnectVariableDispatchProps & AdditionnalProps_12>, connectorOptions?: {
+        memoizeStateToProps?: boolean | undefined;
+    } | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & import("./connectVariable").ConnectVariableOwnProps & AdditionnalProps_12 & {
+        store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+    }>;
+    connectWizardWrapper: <AdditionnalProps_13 = {}>(Component: import("react").ComponentType<import("./connectWizardWrapper").ConnectWizardWrapperDispatchProps & AdditionnalProps_13>, connectorOptions?: {
+        memoizeStateToProps?: boolean | undefined;
+    } | undefined) => ((props: any) => JSX.Element) | import("react-redux").ConnectedComponent<import("react").ComponentClass<any, any> | import("react").FunctionComponent<any>, import("react-redux").Omit<any, never> & AdditionnalProps_13 & {
+        store?: import("redux").Store<any, import("redux").AnyAction> | undefined;
+    }>;
     componentConnector: typeof componentConnector;
 };

package/dist/config.test.d.ts

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

package/dist/config.test.js

@@ -0,0 +1,54 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { getConfig, updateConfig } from './config';
+describe('Config loader', () => {
+    it('Updates config properly', () => __awaiter(void 0, void 0, void 0, function* () {
+        const config = {
+            apiEndpoint: process.env.REACT_APP_API_ENDPOINT || '',
+            enableShadowInstance: false,
+            router: {
+                wizardPath: '/contrats/:prefix?/:permalink/creer/:page?',
+                wizardInstancePath: '/contrats/:prefix?/:permalink/continuer/:uniqid([0-9a-zA-Z]+)/:page?',
+                notFoundPath: '/contrats/conditions-generales-de-vente/creer',
+                appStatesPages: {
+                    termsheet: 'resume',
+                    email: 'email',
+                },
+                smartscriptPath: '/contrats/:permalink/smartscript/:uniqid?',
+            },
+            plugins: {
+                b2c_actions: '1.0.0',
+                datalayer: '1.0.0',
+                checkoutX: '1.0.0',
+                authentication: '1.0.0',
+            },
+            theme: {
+                name: 'legacy',
+                params: {
+                    ui: {
+                        topbar: {
+                            previewBtn: false,
+                        },
+                    },
+                    sidebar: {
+                        default: 'preview',
+                        states: {
+                            wizard: 'summary',
+                            email: 'summary',
+                        },
+                    },
+                },
+            },
+            appStates: ['wizard', 'email'],
+        };
+        updateConfig(config);
+        expect(getConfig()).toStrictEqual(config);
+    }));
+});

package/dist/helpers/activitiesHelper.d.ts

@@ -1,5 +1,5 @@
 import type { IActivities } from "../types/autocomplete.type";
 export declare const api: import("axios").AxiosInstance;
-export declare const getAllActivities: (signal?: AbortSignal) => Promise<import("axios").AxiosResponse<any, any>>;
-export declare const initializeActivities: (signal?: AbortSignal) => Promise<void>;
-export declare const searchInActivities: (inputValue: string, limit: number, signal?: AbortSignal) => Promise<Omit<IActivities, "keywords">[]>;
+export declare const getAllActivities: (signal?: AbortSignal | undefined) => Promise<import("axios").AxiosResponse<any, any>>;
+export declare const initializeActivities: (signal?: AbortSignal | undefined) => Promise<void>;
+export declare const searchInActivities: (inputValue: string, limit: number, signal?: AbortSignal | undefined) => Promise<Omit<IActivities, "keywords">[]>;

package/dist/helpers/autocomplete.helper.d.ts

@@ -2,6 +2,6 @@ import type { AutocompleteDatasetType } from "@legalplace/models-v3-types";
 export declare const handleDataGouvCitiesWithInpi: ({ inputValue, dataset, signal, variableId, }: {
     inputValue: string;
     dataset: AutocompleteDatasetType;
-    signal?: AbortSignal;
-    variableId?: string | number;
+    signal?: AbortSignal | undefined;
+    variableId?: string | number | undefined;
 }) => Promise<Record<string, string | number | null | undefined>[]>;

package/dist/helpers/autocomplete.helper.js

@@ -11,7 +11,7 @@ import { DataGouvApi } from "@legalplace/data-gouv";
 import { autocompleteDatasetConfig } from "../constants/autocomplete";
 import { DatasetTypeEnum } from "../types/autocomplete.type";
 import { initializeInpiCities, mixDataGouvAndInpiCities, } from "./inpiCitiesHelper";
-export const handleDataGouvCitiesWithInpi = (_a) => __awaiter(void 0, [_a], void 0, function* ({ inputValue, dataset, signal, variableId, }) {
+export const handleDataGouvCitiesWithInpi = ({ inputValue, dataset, signal, variableId, }) => __awaiter(void 0, void 0, void 0, function* () {
     yield initializeInpiCities();
     if (inputValue.length < 3) {
         return [];

package/dist/helpers/autosave.helper.d.ts

@@ -1,5 +1,15 @@
-import type { Store } from "redux";
-import type { StateType } from "../types/State.type";
-export declare const autoSave: (variablesData: any[], store: Store<StateType, any> & {
+import type { AnyAction, EmptyObject, Store } from "redux";
+import type { StateType } from "../types";
+export declare const getRelatedParentsByVariableId: (variableId: number, index: number) => {
+    id: number;
+    value: Readonly<string | number>;
+    condition: boolean | undefined;
+}[];
+export declare const getAutoCompleteParentVariableId: (variableId: number, index: number, type?: string | undefined) => number | undefined;
+export declare const autoSave: (variablesData: {
+    variablesIds: number[];
+    updateValue: string;
+    index: number;
+}[], store: Store<EmptyObject & StateType, AnyAction> & {
     dispatch: unknown;
 }) => Promise<void>;

package/dist/helpers/autosave.helper.js

@@ -7,8 +7,75 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { PathReader } from "../libs/PathReader";
-export const autoSave = (variablesData, store) => __awaiter(void 0, void 0, void 0, function* () {
-    if (PathReader.isSmartScriptPath())
+import { saveDataAction, selectAutocompleteDataset, selectLinkedVariables, selectOptionReference, selectVariableConditionValue, selectVariableInputByIndex, selectVariableParents, selectVariablesReference, updateVariableAction, } from "../redux";
+import { fetchAutocompleteDataFromInputValue } from "../service";
+import { cleanString } from "../libs";
+export const getRelatedParentsByVariableId = (variableId, index) => {
+    const parentOptionId = selectVariableParents(variableId)[0];
+    const optionData = selectOptionReference(parentOptionId);
+    const variablesSection = selectVariablesReference(optionData === null || optionData === void 0 ? void 0 : optionData.variables);
+    return variablesSection
+        .filter((variableItem) => variableItem.type === "autocomplete" &&
+        Object.values((variableItem === null || variableItem === void 0 ? void 0 : variableItem.linkedVariables) || []).includes(variableId))
+        .map((parentVariable) => ({
+        id: parentVariable.id,
+        value: selectVariableInputByIndex(parentVariable.id, index) || "",
+        condition: selectVariableConditionValue(parentVariable.id, index),
+    }));
+};
+export const getAutoCompleteParentVariableId = (variableId, index, type) => {
+    if (type === "autocomplete") {
+        return variableId;
+    }
+    const autoCompleteParents = getRelatedParentsByVariableId(variableId, index);
+    if (autoCompleteParents.length) {
+        const { id: idParent } = autoCompleteParents[0];
+        return idParent;
+    }
+    return undefined;
+};
+const getResultAutoComplete = (variableId, updateValue, index, store) => __awaiter(void 0, void 0, void 0, function* () {
+    const linkedVariables = selectLinkedVariables(variableId);
+    const autocompleteDataset = selectAutocompleteDataset(variableId);
+    const autocompleteResults = yield fetchAutocompleteDataFromInputValue({
+        dataset: autocompleteDataset,
+        inputValue: cleanString(updateValue),
+        attributes: Object.keys(linkedVariables || {}),
+        variableId,
+    });
+    if (!autocompleteResults) {
+        window.parent.postMessage({ from: "WIZARD", data: "ERROR" }, "*");
         return;
+    }
+    if (autocompleteResults.length) {
+        const selectedValue = autocompleteResults[0];
+        yield store.dispatch(updateVariableAction(variableId, (selectedValue === null || selectedValue === void 0 ? void 0 : selectedValue.field) || (selectedValue === null || selectedValue === void 0 ? void 0 : selectedValue.primary) || updateValue, index));
+        Object.entries(linkedVariables || {}).forEach(([key, linkedVariableId]) => __awaiter(void 0, void 0, void 0, function* () {
+            yield store.dispatch(updateVariableAction(linkedVariableId, selectedValue[key] || "", index));
+        }));
+        store.dispatch(saveDataAction());
+    }
+});
+export const autoSave = (variablesData, store) => __awaiter(void 0, void 0, void 0, function* () {
+    yield variablesData.forEach((variableData, indexVariablesData) => __awaiter(void 0, void 0, void 0, function* () {
+        yield variableData.variablesIds.forEach((variableId, indexVariable) => __awaiter(void 0, void 0, void 0, function* () {
+            let contentVariable = variableData.updateValue;
+            if (variableData.variablesIds.length > 1) {
+                contentVariable = `${variableData.updateValue.split(",")[indexVariable] || ""}`.trim();
+            }
+            const variable = store.getState().references.variables[variableId];
+            const variableParentId = getAutoCompleteParentVariableId(variableId, variableData.index, variable === null || variable === void 0 ? void 0 : variable.type);
+            if (variableParentId) {
+                yield getResultAutoComplete(variableParentId, contentVariable, variableData.index, store);
+                return;
+            }
+            yield store.dispatch(updateVariableAction(variableId, contentVariable, variableData.index));
+            setTimeout(() => __awaiter(void 0, void 0, void 0, function* () {
+                if (indexVariable === variableData.variablesIds.length - 1 &&
+                    indexVariablesData === variablesData.length - 1) {
+                    store.dispatch(saveDataAction());
+                }
+            }), 200);
+        }));
+    }));
 });

package/dist/helpers/inpiCitiesHelper.js

@@ -68,8 +68,8 @@ function addressKey(address) {
     return address.postcode;
 }
 export function mixDataGouvAndInpiCities(dataGouvResult, inputValue) {
+    var _a;
     return __awaiter(this, void 0, void 0, function* () {
-        var _a;
         if (!cachedInpiCities) {
             yield initializeInpiCities();
         }

package/dist/helpers/outputsParsing.d.ts

@@ -1,18 +1,18 @@
 import type { OptionsVariablesType } from "../libs/InputsInitiator";
-export type relVarsValsT = Record<string, string | number>;
-export type getRelatedVarsT = (optionId: number, index: number, variables: number[]) => relVarsValsT;
+export declare type relVarsValsT = Record<string, string | number>;
+export declare type getRelatedVarsT = (optionId: number, index: number, variables: number[]) => relVarsValsT;
 export declare const getRelatedVariablesValues: getRelatedVarsT;
-export type parseContentT = (output: string, id: number, index: number, variables: relVarsValsT) => string;
+export declare type parseContentT = (output: string, id: number, index: number, variables: relVarsValsT) => string;
 export declare const parseContentWithVariables: parseContentT;
-export type autonumsType = [string, string, number, string | null][];
-export type parseOutputT = (output: string, id: number, index: number, variables: relVarsValsT, autonums: autonumsType) => string;
+export declare type autonumsType = [string, string, number, string | null][];
+export declare type parseOutputT = (output: string, id: number, index: number, variables: relVarsValsT, autonums: autonumsType) => string;
 export declare const parseOutputWithVariables: parseOutputT;
-export type parseVariableLabelT = (id: number, index: number) => string;
+export declare type parseVariableLabelT = (id: number, index: number) => string;
 export declare const parseVariableLabel: parseVariableLabelT;
-export type parseOptionLabelT = (id: number, index: number) => string;
+export declare type parseOptionLabelT = (id: number, index: number) => string;
 export declare const parseOptionLabel: parseOptionLabelT;
-export type parseRawT = (text: string, inputs?: OptionsVariablesType, placeholder?: string) => string;
+export declare type parseRawT = (text: string, inputs?: OptionsVariablesType, placeholder?: string) => string;
 export declare const parseRawWithVariables: parseRawT;
-export type parseRawWithRelatedVariablesT = (text: string, optionId: number, index: number, inputs?: OptionsVariablesType, placeholder?: string) => string;
+export declare type parseRawWithRelatedVariablesT = (text: string, optionId: number, index: number, inputs?: OptionsVariablesType, placeholder?: string) => string;
 export declare const parseRawWithRelatedVariables: parseRawWithRelatedVariablesT;
 export declare const parsePrefillerValue: (variableId: number, inputIndex: number, prefillerIndex: number) => string;