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

package/dist/componentsConnectors/library.d.ts

@@ -1,89 +1,55 @@
 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;
-    } | 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;
+        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;
     } & {
         title: string;
-    } & 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;
-    }>;
+    } & 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;
     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_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;
-    }>;
+    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;
     componentConnector: typeof componentConnector;
 };

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 | 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">[]>;
+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">[]>;

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 | undefined;
-    variableId?: string | number | undefined;
+    signal?: AbortSignal;
+    variableId?: string | number;
 }) => 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 = ({ inputValue, dataset, signal, variableId, }) => __awaiter(void 0, void 0, void 0, function* () {
+export const handleDataGouvCitiesWithInpi = (_a) => __awaiter(void 0, [_a], void 0, function* ({ inputValue, dataset, signal, variableId, }) {
     yield initializeInpiCities();
     if (inputValue.length < 3) {
         return [];

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

@@ -1,15 +1,5 @@
-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> & {
+import type { Store } from "redux";
+import type { StateType } from "../types/State.type";
+export declare const autoSave: (variablesData: any[], store: Store<StateType, any> & {
     dispatch: unknown;
 }) => Promise<void>;

package/dist/helpers/autosave.helper.js

@@ -7,75 +7,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-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());
-    }
-});
+import { PathReader } from "../libs/PathReader";
 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);
-        }));
-    }));
+    if (PathReader.isSmartScriptPath())
+        return;
 });

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 declare type relVarsValsT = Record<string, string | number>;
-export declare type getRelatedVarsT = (optionId: number, index: number, variables: number[]) => relVarsValsT;
+export type relVarsValsT = Record<string, string | number>;
+export type getRelatedVarsT = (optionId: number, index: number, variables: number[]) => relVarsValsT;
 export declare const getRelatedVariablesValues: getRelatedVarsT;
-export declare type parseContentT = (output: string, id: number, index: number, variables: relVarsValsT) => string;
+export type parseContentT = (output: string, id: number, index: number, variables: relVarsValsT) => string;
 export declare const parseContentWithVariables: parseContentT;
-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 type autonumsType = [string, string, number, string | null][];
+export type parseOutputT = (output: string, id: number, index: number, variables: relVarsValsT, autonums: autonumsType) => string;
 export declare const parseOutputWithVariables: parseOutputT;
-export declare type parseVariableLabelT = (id: number, index: number) => string;
+export type parseVariableLabelT = (id: number, index: number) => string;
 export declare const parseVariableLabel: parseVariableLabelT;
-export declare type parseOptionLabelT = (id: number, index: number) => string;
+export type parseOptionLabelT = (id: number, index: number) => string;
 export declare const parseOptionLabel: parseOptionLabelT;
-export declare type parseRawT = (text: string, inputs?: OptionsVariablesType, placeholder?: string) => string;
+export type parseRawT = (text: string, inputs?: OptionsVariablesType, placeholder?: string) => string;
 export declare const parseRawWithVariables: parseRawT;
-export declare type parseRawWithRelatedVariablesT = (text: string, optionId: number, index: number, inputs?: OptionsVariablesType, placeholder?: string) => string;
+export 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;

package/dist/hooks/useDispatch.d.ts

@@ -1 +1 @@
-export declare function useDispatch(): import("redux").Dispatch<import("redux").AnyAction>;
+export declare function useDispatch(): import("redux").Dispatch<any>;

package/dist/hooks/usePrevious.js

@@ -3,6 +3,6 @@ export const usePrevious = (value) => {
     const ref = useRef();
     useEffect(() => {
         ref.current = value;
-    });
+    }, []);
     return ref.current;
 };

package/dist/index.d.ts

@@ -1,5 +1,8 @@
 export { default as App } from "./App";
 export * from "./App";
+export { default as WizardCore } from "./WizardCore";
+export * from "./WizardCore";
+export * from "./routing";
 export * from "./config";
 export * from "./Globals";
 export * from "./PluginLoader";

package/dist/index.js

@@ -1,5 +1,8 @@
 export { default as App } from "./App";
 export * from "./App";
+export { default as WizardCore } from "./WizardCore";
+export * from "./WizardCore";
+export * from "./routing";
 export * from "./config";
 export * from "./Globals";
 export * from "./PluginLoader";

package/dist/libs/ConditionsRunner.d.ts

@@ -1,6 +1,6 @@
 import type { Dispatch } from "redux";
 import type { StateType, MAPPED_CONDITIONS } from "../types/State.type";
-export declare type AllConditions = StateType.Conditions.Options | StateType.Conditions.Variables | StateType.Conditions.Validators | StateType.Conditions.Prefillers | StateType.Conditions.Sections | any[];
+export type AllConditions = StateType.Conditions.Options | StateType.Conditions.Variables | StateType.Conditions.Validators | StateType.Conditions.Prefillers | StateType.Conditions.Sections | any[];
 export declare class ConditionsRunner {
     dispatch: Dispatch;
     constructor(dispatch: Dispatch);

package/dist/libs/Formatter/FormatAddress.d.ts

@@ -1 +1 @@
-export declare const cleanString: (str?: string | undefined) => string;
+export declare const cleanString: (str?: string) => string;

package/dist/libs/InputsInitiator.d.ts

@@ -1,5 +1,5 @@
 import type { StateType } from "../types/State.type";
-export declare type OptionsVariablesType = {
+export type OptionsVariablesType = {
     options: {
         [key: string]: boolean[];
     };

package/dist/libs/PathReader.d.ts

@@ -21,7 +21,102 @@ export declare class PathReader {
         appStates: string[];
     };
     getAppStatesPages(): {
-        [x: string]: string;
+        length: number;
+        toString(): string;
+        toLocaleString(): string;
+        toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string;
+        pop(): string | undefined;
+        push(...items: string[]): number;
+        concat(...items: ConcatArray<string>[]): string[];
+        concat(...items: (string | ConcatArray<string>)[]): string[];
+        join(separator?: string): string;
+        reverse(): string[];
+        shift(): string | undefined;
+        slice(start?: number, end?: number): string[];
+        sort(compareFn?: ((a: string, b: string) => number) | undefined): string[];
+        splice(start: number, deleteCount?: number): string[];
+        splice(start: number, deleteCount: number, ...items: string[]): string[];
+        unshift(...items: string[]): number;
+        indexOf(searchElement: string, fromIndex?: number): number;
+        lastIndexOf(searchElement: string, fromIndex?: number): number;
+        every<S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): this is S[];
+        every(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): boolean;
+        some(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): boolean;
+        forEach(callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any): void;
+        map<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[];
+        filter<S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S[];
+        filter(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): string[];
+        reduce(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string;
+        reduce(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string;
+        reduce<U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U;
+        reduceRight(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string;
+        reduceRight(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string;
+        reduceRight<U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U;
+        find<S extends string>(predicate: (value: string, index: number, obj: string[]) => value is S, thisArg?: any): S | undefined;
+        find(predicate: (value: string, index: number, obj: string[]) => unknown, thisArg?: any): string | undefined;
+        findIndex(predicate: (value: string, index: number, obj: string[]) => unknown, thisArg?: any): number;
+        fill(value: string, start?: number, end?: number): string[];
+        copyWithin(target: number, start: number, end?: number): string[];
+        entries(): ArrayIterator<[number, string]>;
+        keys(): ArrayIterator<number>;
+        values(): ArrayIterator<string>;
+        includes(searchElement: string, fromIndex?: number): boolean;
+        flatMap<U, This = undefined>(callback: (this: This, value: string, index: number, array: string[]) => U | readonly U[], thisArg?: This | undefined): U[];
+        flat<A, D extends number = 1>(this: A, depth?: D | undefined): FlatArray<A, D>[];
+        at(index: number): string | undefined;
+        findLast<S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S | undefined;
+        findLast(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): string | undefined;
+        findLastIndex(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): number;
+        toReversed(): string[];
+        toSorted(compareFn?: ((a: string, b: string) => number) | undefined): string[];
+        toSpliced(start: number, deleteCount: number, ...items: string[]): string[];
+        toSpliced(start: number, deleteCount?: number): string[];
+        with(index: number, value: string): string[];
+        [Symbol.iterator](): ArrayIterator<string>;
+        [Symbol.unscopables]: {
+            [x: number]: boolean | undefined;
+            length?: boolean | undefined;
+            toString?: boolean | undefined;
+            toLocaleString?: boolean | undefined;
+            pop?: boolean | undefined;
+            push?: boolean | undefined;
+            concat?: boolean | undefined;
+            join?: boolean | undefined;
+            reverse?: boolean | undefined;
+            shift?: boolean | undefined;
+            slice?: boolean | undefined;
+            sort?: boolean | undefined;
+            splice?: boolean | undefined;
+            unshift?: boolean | undefined;
+            indexOf?: boolean | undefined;
+            lastIndexOf?: boolean | undefined;
+            every?: boolean | undefined;
+            some?: boolean | undefined;
+            forEach?: boolean | undefined;
+            map?: boolean | undefined;
+            filter?: boolean | undefined;
+            reduce?: boolean | undefined;
+            reduceRight?: boolean | undefined;
+            find?: boolean | undefined;
+            findIndex?: boolean | undefined;
+            fill?: boolean | undefined;
+            copyWithin?: boolean | undefined;
+            entries?: boolean | undefined;
+            keys?: boolean | undefined;
+            values?: boolean | undefined;
+            includes?: boolean | undefined;
+            flatMap?: boolean | undefined;
+            flat?: boolean | undefined;
+            at?: boolean | undefined;
+            findLast?: boolean | undefined;
+            findLastIndex?: boolean | undefined;
+            toReversed?: boolean | undefined;
+            toSorted?: boolean | undefined;
+            toSpliced?: boolean | undefined;
+            with?: boolean | undefined;
+            [Symbol.iterator]?: boolean | undefined;
+            readonly [Symbol.unscopables]?: boolean | undefined;
+        };
     };
     parsePath(page?: number, uniqid?: string | undefined, modelVersion?: string | undefined): string;
     static isWizardInstancePath(): boolean;

package/dist/libs/PathReader.js

@@ -2,7 +2,6 @@ import { createMatchSelector } from "connected-react-router";
 import queryString from "query-string";
 import { matchPath, generatePath } from "react-router";
 import { getConfig } from "../config";
-import { getPluginsPageAppStates } from "../PluginLoader";
 import { selectAvailableSections, selectAvailableAppStates, selectInstanceUniqid, selectMetaFetchStatus, } from "../redux/selectors/app";
 import { selectSectionReference } from "../redux/selectors/references";
 import Globals from "../Globals";
@@ -125,7 +124,7 @@ export class PathReader {
     }
     getAppStatesPages() {
         const globalAppStates = getConfig().router.appStatesPages || {};
-        const pluginsAppStates = getPluginsPageAppStates();
+        const pluginsAppStates = [];
         return Object.assign(Object.assign({}, globalAppStates), pluginsAppStates);
     }
     parsePath(page = this.currentPage, uniqid = this.currentUniqid, modelVersion = this.modelVersion) {

package/dist/libs/SmartScriptStore.d.ts

@@ -1,7 +1,7 @@
 import type { Action } from "redux";
 import type { ActionsType } from "../types/Actions.type";
 import type { StateType } from "../types/State.type";
-export declare type CallbackType = () => void;
+export type CallbackType = () => void;
 export declare class SmartScriptStore {
     static hooks: {
         variables: Record<string, CallbackType[]>;
@@ -29,11 +29,11 @@ export declare class SmartScriptStore {
     static onVariableChange(id: number | number[], callback: CallbackType): void;
     static updateVariableInput: (id: number, value: string | number, index?: number) => void;
     static updateOptionInput: (id: number, value: boolean, index?: number) => void;
-    static updateVariableMeta: (id: number, _meta: ActionsType.References.updateVariableMeta["meta"], index?: number | undefined) => void;
+    static updateVariableMeta: (id: number, _meta: ActionsType.References.updateVariableMeta["meta"], index?: number) => void;
     static updateOptionMeta: (id: number, _meta: ActionsType.References.updateOptionMeta["meta"]) => void;
     static retrieveExternalData: () => Readonly<false | any[]>;
-    static hideOption: (id: number, index?: number | undefined) => void;
-    static displayOption: (id: number, index?: number | undefined) => void;
-    static hideVariable: (id: number, index?: number | undefined) => void;
-    static displayVariable: (id: number, index?: number | undefined) => void;
+    static hideOption: (id: number, index?: number) => void;
+    static displayOption: (id: number, index?: number) => void;
+    static hideVariable: (id: number, index?: number) => void;
+    static displayVariable: (id: number, index?: number) => void;
 }

package/dist/redux/actions/app.d.ts

@@ -13,7 +13,7 @@ export declare const setFetchStatus: (fetchStatus: "waiting" | "succeeded" | "fa
 export declare const initInstanceAction: (instance: StateType.App.Instance) => ActionsType.App.initInstance;
 export declare const updateInstanceAction: (instance: Partial<StateType.App.Instance>) => ActionsType.App.updateInstance;
 export declare const updateInstancePaidAction: (isPaid: boolean) => ActionsType.App.updateInstancePaid;
-export declare type initPaginationActionPropsType = Omit<ActionsType.App.initPagination, "type">;
+export type initPaginationActionPropsType = Omit<ActionsType.App.initPagination, "type">;
 export declare const initPaginationAction: (pagination: initPaginationActionPropsType) => ActionsType.App.initPagination;
 export declare const updateAvailableAppStatesAction: (availableAppStates: StateType.App.Pagination["availableAppStates"], ingorePluginAppStateReset?: boolean) => ActionsType.App.updateAvailableAppStates;
 export declare const goPageAction: (page: number, pushHistory?: boolean) => ActionsType.App.goPage;

package/dist/redux/actions/inputs.d.ts

@@ -1,6 +1,6 @@
 import type { StateType } from "../../types/State.type";
 import type { ActionsType } from "../../types/Actions.type";
-export declare const initInputsAction: (inputs: StateType.Inputs, references?: StateType.References | undefined) => ActionsType.Inputs.initInputs;
+export declare const initInputsAction: (inputs: StateType.Inputs, references?: StateType.References) => ActionsType.Inputs.initInputs;
 export declare const initOptionAction: (id: number, values: boolean[]) => ActionsType.Inputs.initOption;
 export declare const updateOptionAction: (id: number, value: boolean, index: number) => ActionsType.Inputs.updateOptionInput;
 export declare const initVariableAction: (id: number, values: (string | number)[]) => ActionsType.Inputs.initVariable;