@legalplace/wizardx-core 0.0.1-alpha.0

package/dist/helpers/outputsParsing.d.ts

@@ -0,0 +1,15 @@
+import { OVC_TYPE } from '..';
+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 declare 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 declare const parseOutputWithVariables: parseOutputT;
+export declare type parseVariableLabelT = (id: number, index: number) => string;
+export declare const parseVariableLabel: parseVariableLabelT;
+export declare type parseOptionLabelT = (id: number, index: number) => string;
+export declare const parseOptionLabel: parseOptionLabelT;
+export declare type parseRawT = (text: string, inputs?: OVC_TYPE, placeholder?: string) => string;
+export declare const parseRawWithVariables: parseRawT;

package/dist/helpers/outputsParsing.js

@@ -0,0 +1,186 @@
+import { filterXSS } from 'xss';
+import { selectVariableParents, selectOptionRelations, selectVariableReference, selectOptionReference, selectVariableRelations, } from '../redux/selectors/references';
+import { selectVariableInput, selectVariableInputByIndex, } from '../redux/selectors/inputs';
+const frenchNumber = (value) => {
+    let result = typeof value === 'number' ? value.toString() : value;
+    if (/^([0-9]+)\.([0-9]+)$/.test(result.trim()))
+        result = result.trim().replace('.', ',');
+    return result;
+};
+export const getRelatedVariablesValues = (optionId, index, variables) => {
+    const variablesValues = {};
+    variables.forEach((currentVariableId) => {
+        let value = selectVariableInput(currentVariableId);
+        const variableParents = selectVariableParents(currentVariableId);
+        if (variableParents === undefined)
+            throw new Error(`Variable ${currentVariableId} parents object does not exist`);
+        const rootVariableParentId = variableParents[variableParents.length - 1];
+        const rootVariableParentRelations = selectOptionRelations(rootVariableParentId);
+        if (rootVariableParentRelations === undefined)
+            throw new Error(`Option ${rootVariableParentId} does not exist`);
+        if (typeof variableParents === 'undefined')
+            return;
+        if (rootVariableParentRelations.children.options.includes(optionId) ||
+            rootVariableParentRelations.dependants.includes(optionId) ||
+            optionId === rootVariableParentId)
+            value = [value[index]];
+        const cleanValues = value.map((currentValue) => {
+            if (['number', 'string'].includes(typeof currentValue))
+                return frenchNumber(currentValue);
+            return '';
+        });
+        let currentVariableValue = cleanValues.length === 1 ? cleanValues[0] : cleanValues.join(', ');
+        currentVariableValue = currentVariableValue.replace(/\n/g, '<br />');
+        variablesValues[currentVariableId] = currentVariableValue;
+    });
+    return variablesValues;
+};
+const contentParsingCache = {};
+export const parseContentWithVariables = (content, id, index, variables) => {
+    const variablesKey = Object.keys(variables).map((variableId) => `${variableId}:${variables[variableId]};`);
+    const cacheKey = `${id}-${index}-${content}-${variablesKey}`;
+    if (Object.prototype.hasOwnProperty.call(contentParsingCache, cacheKey)) {
+        return contentParsingCache[cacheKey];
+    }
+    let parsedContent = `${content}`;
+    Object.keys(variables).forEach((variableId) => {
+        let value = variables[variableId].toString();
+        if (value.trim().length === 0) {
+            value = new Array(16).join('_');
+        }
+        parsedContent = parsedContent.replace(new RegExp(`\\[var:${variableId}\\]`, 'gi'), filterXSS(value, {
+            whiteList: {
+                a: [],
+            },
+        }));
+    });
+    contentParsingCache[cacheKey] = parsedContent;
+    return contentParsingCache[cacheKey];
+};
+const outputParsingCache = {};
+export const parseOutputWithVariables = (output, id, index, variables, autonums) => {
+    const variablesKey = Object.keys(variables).map((variableId) => `${variableId}:${variables[variableId]};`);
+    const autonumsKey = autonums.map((autonum) => `${autonum[1]}:${autonum[2]};`);
+    const cacheKey = `${id}-${index}-${variablesKey}-${autonumsKey}`;
+    if (Object.prototype.hasOwnProperty.call(outputParsingCache, cacheKey)) {
+        return outputParsingCache[cacheKey];
+    }
+    let parsedOutput = `${output}`;
+    Object.keys(variables).forEach((variableId) => {
+        let value = variables[variableId].toString();
+        if (value.trim().length === 0) {
+            value = new Array(16).join('_');
+        }
+        parsedOutput = parsedOutput.replace(new RegExp(`\\[var:${variableId}\\]`, 'gi'), filterXSS(value));
+    });
+    parsedOutput = parsedOutput.replace(/\[\[PAGE_BREAK\]\]/gi, '<p class="pagebreak"><!-- pagebreak --></p>');
+    parsedOutput = parsedOutput.replace(/\[(E|B)_BLUR\]/gi, '');
+    parsedOutput = parsedOutput.replace(/\[signature:([0-9]+)\]/g, '');
+    autonums.forEach((currentAn) => {
+        if (currentAn[3] === null)
+            parsedOutput = parsedOutput.replace(`[${currentAn[0]}:${currentAn[1]}]`, `<span class="${currentAn[0]}">${currentAn[2]}</span>`);
+        else
+            parsedOutput = parsedOutput.replace(`[${currentAn[0]}:${currentAn[1]}](${currentAn[3]})`, `<span class="${currentAn[0]}">${currentAn[2]}</span>`);
+    });
+    outputParsingCache[cacheKey] = parsedOutput;
+    return outputParsingCache[cacheKey];
+};
+export const parseVariableLabel = (id, index = 0) => {
+    const { label, fallbackLabel } = selectVariableReference(id);
+    if (!/\[var:([0-9]+)\]/gi.test(label))
+        return label;
+    const variablesList = [];
+    const matchs = Array.from(label.matchAll(/\[var:([0-9]+)\]/g));
+    matchs.forEach((currentMatch) => {
+        variablesList.push(parseInt(currentMatch[1], 10));
+    });
+    const parentOptionId = selectVariableRelations(id).parents[0];
+    const relatedVariables = getRelatedVariablesValues(parentOptionId, index, variablesList);
+    const variablesValues = {};
+    let useFallback = null;
+    variablesList.forEach((variableId) => {
+        const value = relatedVariables[variableId];
+        if (value === undefined ||
+            value === null ||
+            (typeof value === 'string' && value.trim().length === 0)) {
+            useFallback = true;
+            return;
+        }
+        variablesValues[variableId] = value.toString();
+    });
+    if (useFallback === true && typeof fallbackLabel === 'string')
+        return fallbackLabel;
+    let parsedLabel = `${label}`;
+    variablesList.forEach((variableId) => {
+        const value = variablesValues[variableId];
+        parsedLabel = parsedLabel.replace(new RegExp(`\\[var:${variableId}\\]`, 'gi'), filterXSS(value));
+    });
+    return parsedLabel;
+};
+export const parseOptionLabel = (id, index = 0) => {
+    const { label, fallbackLabel } = selectOptionReference(id).meta;
+    if (!/\[var:([0-9]+)\]/gi.test(label))
+        return label;
+    const variablesList = [];
+    const matchs = Array.from(label.matchAll(/\[var:([0-9]+)\]/g));
+    matchs.forEach((currentMatch) => {
+        variablesList.push(parseInt(currentMatch[1], 10));
+    });
+    const relatedVariables = getRelatedVariablesValues(id, index, variablesList);
+    const variablesValues = {};
+    let useFallback = null;
+    variablesList.forEach((variableId) => {
+        const value = relatedVariables[variableId];
+        if (value === undefined ||
+            value === null ||
+            (typeof value === 'string' && value.trim().length === 0)) {
+            useFallback = true;
+            return;
+        }
+        variablesValues[variableId] = value.toString();
+    });
+    if (useFallback === true && typeof fallbackLabel === 'string')
+        return fallbackLabel;
+    let parsedLabel = `${label}`;
+    variablesList.forEach((variableId) => {
+        const value = variablesValues[variableId];
+        parsedLabel = parsedLabel.replace(new RegExp(`\\[var:${variableId}\\]`, 'gi'), filterXSS(value));
+    });
+    return parsedLabel;
+};
+export const parseRawWithVariables = (text, inputs, placeholder) => {
+    const tagsMatch = text.match(/\[var:([0-9]+)\]/gi);
+    let variables = [];
+    if (tagsMatch !== null) {
+        const variablesTags = [...tagsMatch];
+        variables = variablesTags.map((current) => {
+            const outputVariableMatch = current.match(/([0-9]+)/);
+            if (outputVariableMatch === null)
+                return 0;
+            return parseInt(outputVariableMatch[0], 10);
+        });
+    }
+    variables = variables.filter((c, i) => variables.indexOf(c) === i);
+    variables = variables.filter((c) => inputs !== undefined || selectVariableReference(c) !== undefined);
+    const variablesValues = {};
+    variables.forEach((variableId) => {
+        var _a;
+        const value = inputs
+            ? (_a = inputs.variables[variableId]) === null || _a === void 0 ? void 0 : _a[0]
+            : selectVariableInputByIndex(variableId, 0);
+        if (value === undefined ||
+            value === null ||
+            (typeof value === 'string' && value.trim().length === 0)) {
+            variablesValues[variableId] = placeholder || '';
+        }
+        else {
+            variablesValues[variableId] = value.toString();
+        }
+    });
+    let parsedText = `${text}`;
+    variables.forEach((variableId) => {
+        const value = variablesValues[variableId];
+        parsedText = parsedText.replace(new RegExp(`\\[var:${variableId}\\]`, 'gi'), filterXSS(value));
+    });
+    return parsedText;
+};

package/dist/helpers/sendinblueHelper.d.ts

@@ -0,0 +1,4 @@
+export declare const getSIBExtract: () => {
+    [k: string]: string;
+} | undefined;
+export declare const getSendinblueIdentifyAttributes: (uniqid: string, documentTitle: string, nbFilledVars: number, VALIDATION_Q2?: boolean, domain?: string) => Record<string, string | number | undefined | boolean | null>;

package/dist/helpers/sendinblueHelper.js

@@ -0,0 +1,35 @@
+import PhoneNumber from 'awesome-phonenumber';
+import Extracts from '../libs/Extracts';
+import { pardotAttributes } from '../service/pardot.service';
+const formatMobilePhone = (phoneNumber) => {
+    var _a;
+    const sanitizedNumber = new PhoneNumber(phoneNumber, 'FR');
+    return !((_a = sanitizedNumber === null || sanitizedNumber === void 0 ? void 0 : sanitizedNumber.getNumber()) === null || _a === void 0 ? void 0 : _a.length) || !sanitizedNumber.isMobile()
+        ? ''
+        : sanitizedNumber.getNumber();
+};
+export const getSIBExtract = () => {
+    let sibExtract;
+    try {
+        Extracts.extractData();
+        sibExtract = Extracts.getSibExtractedData();
+        if (sibExtract.TEL) {
+            try {
+                sibExtract.SMS = formatMobilePhone(sibExtract.TEL);
+            }
+            catch (error) {
+            }
+        }
+    }
+    catch (error) {
+        console.error('Error while extracting sendiblue data', error);
+    }
+    return sibExtract;
+};
+export const getSendinblueIdentifyAttributes = (uniqid, documentTitle, nbFilledVars, VALIDATION_Q2 = false, domain = 'www.legalplace.fr') => {
+    const sendinblueVars = Object.assign(Object.assign(Object.assign({ UNIQID: uniqid, AB: Math.floor(Math.random() * 2), TELECHARGEMENT: `${domain}/rt/${uniqid}`, DOCUMENT: documentTitle, WIZZARD_FILLED_FIELDS: nbFilledVars }, getSIBExtract()), pardotAttributes()), { VALIDATION_Q2 });
+    if (localStorage && localStorage.getItem('entranceUrl')) {
+        sendinblueVars.URL_ENTREE = localStorage.getItem('entranceUrl');
+    }
+    return sendinblueVars;
+};

package/dist/hooks/index.d.ts

@@ -0,0 +1 @@
+export * from './usePrevious';

package/dist/hooks/index.js

@@ -0,0 +1 @@
+export * from './usePrevious';

package/dist/hooks/usePrevious.d.ts

@@ -0,0 +1 @@
+export declare const usePrevious: <T>(value: T) => T | undefined;

package/dist/hooks/usePrevious.js

@@ -0,0 +1,8 @@
+import { useRef, useEffect } from 'react';
+export const usePrevious = (value) => {
+    const ref = useRef();
+    useEffect(() => {
+        ref.current = value;
+    });
+    return ref.current;
+};

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+import 'react-app-polyfill/ie11';
+import 'react-app-polyfill/stable';
+import './polyfills/stringRepeat';
+import './polyfills/prepend';
+import './polyfills/objectValues';
+import App from './App';
+export * from './config';
+export * from './PluginLoader';
+export * from './ThemeLoader';
+export * from './hooks';
+export * from './helpers';
+export * from './constants';
+export * from './redux';
+export * as reduxSelectorsList from './redux/selectors';
+export * from './componentsConnectors';
+export * as componentsConnectorsList from './componentsConnectors';
+export * from './libs';
+export * from './service';
+export * from './types/getConnectors.type';
+export * from './componentsConnectors/connector/componentConnector';
+export * from './types/State.type';
+export * from './types';
+export default App;

package/dist/index.js

@@ -0,0 +1,23 @@
+import 'react-app-polyfill/ie11';
+import 'react-app-polyfill/stable';
+import './polyfills/stringRepeat';
+import './polyfills/prepend';
+import './polyfills/objectValues';
+import App from './App';
+export * from './config';
+export * from './PluginLoader';
+export * from './ThemeLoader';
+export * from './hooks';
+export * from './helpers';
+export * from './constants';
+export * from './redux';
+export * as reduxSelectorsList from './redux/selectors';
+export * from './componentsConnectors';
+export * as componentsConnectorsList from './componentsConnectors';
+export * from './libs';
+export * from './service';
+export * from './types/getConnectors.type';
+export * from './componentsConnectors/connector/componentConnector';
+export * from './types/State.type';
+export * from './types';
+export default App;

package/dist/libs/ConditionsInitiator.d.ts

@@ -0,0 +1,16 @@
+import { StateType } from '../types/State.type';
+export declare class ConditionsInitiator {
+    private conditions;
+    private references;
+    private inputs;
+    constructor(references: StateType.References, inputs: StateType.Inputs);
+    private getOptionOccurencyLength;
+    private getVariableOccurencyLength;
+    private initOptionsConditions;
+    private initVariablesConditions;
+    private initDocumentsConditions;
+    private initSectionsConditions;
+    private initPrefilliersConditions;
+    private initValidators;
+    getConditions(): StateType.Conditions;
+}

package/dist/libs/ConditionsInitiator.js

@@ -0,0 +1,88 @@
+export class ConditionsInitiator {
+    constructor(references, inputs) {
+        this.conditions = {
+            options: {},
+            variables: {},
+            sections: {},
+            documents: {},
+            prefillers: {},
+            validators: {
+                options: {},
+                variables: {},
+            },
+        };
+        this.references = references;
+        this.inputs = inputs;
+        this.initOptionsConditions();
+        this.initVariablesConditions();
+        this.initDocumentsConditions();
+        this.initSectionsConditions();
+        this.initPrefilliersConditions();
+        this.initValidators();
+    }
+    getOptionOccurencyLength(optionId) {
+        const { parents } = this.references.relations.options[optionId];
+        if (parents === undefined)
+            throw new Error(`Cannot find parents for option ${optionId}`);
+        const rootParent = parents[parents.length - 1] || optionId;
+        const rootReference = this.references.options[rootParent];
+        const occurenciesOptionId = rootReference.meta.type === 'repeated' &&
+            rootReference.meta.repeatOption !== undefined
+            ? rootReference.meta.repeatOption
+            : rootParent;
+        const inputs = this.inputs.options[occurenciesOptionId];
+        return inputs.length;
+    }
+    getVariableOccurencyLength(variableId) {
+        const { parents } = this.references.relations.variables[variableId];
+        if (parents === undefined || parents.length === 0)
+            throw new Error(`Cannot find parents for variable ${variableId}`);
+        const rootParent = parents[parents.length - 1];
+        const rootReference = this.references.options[rootParent];
+        const occurenciesOptionId = rootReference.meta.type === 'repeated' &&
+            rootReference.meta.repeatOption !== undefined
+            ? rootReference.meta.repeatOption
+            : rootParent;
+        const inputs = this.inputs.options[occurenciesOptionId];
+        return inputs.length;
+    }
+    initOptionsConditions() {
+        Object.keys(this.references.conditions.options).forEach((optionId) => {
+            this.conditions.options[optionId] = new Array(this.getOptionOccurencyLength(optionId)).fill(false);
+        });
+    }
+    initVariablesConditions() {
+        Object.keys(this.references.conditions.variables).forEach((variableId) => {
+            this.conditions.variables[variableId] = new Array(this.getVariableOccurencyLength(variableId)).fill(false);
+        });
+    }
+    initDocumentsConditions() {
+        Object.keys(this.references.conditions.documents).forEach((documentName) => {
+            this.conditions.documents[documentName] = false;
+        });
+    }
+    initSectionsConditions() {
+        Object.keys(this.references.conditions.sections).forEach((documentName) => {
+            this.conditions.sections[documentName] = {};
+            Object.keys(this.references.conditions.sections[documentName]).forEach((sectionId) => {
+                this.conditions.sections[documentName][sectionId] = false;
+            });
+        });
+    }
+    initPrefilliersConditions() {
+        Object.keys(this.references.conditions.prefillers).forEach((prefillerId) => {
+            this.conditions.prefillers[prefillerId] = new Array(this.getVariableOccurencyLength(prefillerId)).fill(this.references.conditions.prefillers[prefillerId].map(() => false));
+        });
+    }
+    initValidators() {
+        Object.keys(this.references.conditions.validators.options).forEach((optionId) => {
+            this.conditions.validators.options[optionId] = new Array(this.getOptionOccurencyLength(optionId)).fill(false);
+        });
+        Object.keys(this.references.conditions.validators.variables).forEach((variableId) => {
+            this.conditions.validators.variables[variableId] = new Array(this.getVariableOccurencyLength(variableId)).fill(false);
+        });
+    }
+    getConditions() {
+        return this.conditions;
+    }
+}

package/dist/libs/ConditionsRunner/DataPopulator.d.ts

@@ -0,0 +1,37 @@
+declare class DataPopulator {
+    private id?;
+    private index?;
+    private dataMap;
+    private data;
+    constructor(dataMap: ConditionDataMap, id?: number, index?: number);
+    getData(): Readonly<ConditionData>;
+    private populateConditions;
+    private getOptionConditions;
+    private getVariablesConditions;
+    private populateVariables;
+    private getVariableValues;
+    private getVariableRootParent;
+    private cleanArrayFromNullValues;
+    populateOptions(): void;
+    private getOptionInputs;
+    private getOptionRootParent;
+}
+export interface ConditionDataMap {
+    o: number[];
+    v: number[];
+    c: {
+        o: number[];
+        s: number[];
+        v: number[];
+    };
+}
+export interface ConditionData {
+    o: Record<string, boolean[]>;
+    v: Record<string, (string | number)[]>;
+    c: {
+        o: Record<string, boolean[]>;
+        s: Record<string, boolean[]>;
+        v: Record<string, boolean[]>;
+    };
+}
+export default DataPopulator;

package/dist/libs/ConditionsRunner/DataPopulator.js

@@ -0,0 +1,140 @@
+import { selectVariableReference, selectVariableParents, selectOptionRelations, selectOptionParents, } from '../../redux/selectors/references';
+import { selectVariableInput, selectOptionInput, } from '../../redux/selectors/inputs';
+import { selectVariableConditionValue, selectOptionConditionValue, selectSectionConditionValue, } from '../../redux/selectors/conditions';
+class DataPopulator {
+    constructor(dataMap, id, index) {
+        this.data = {
+            o: {},
+            v: {},
+            c: {
+                o: {},
+                s: {},
+                v: {},
+            },
+        };
+        this.id = id;
+        this.index = index;
+        this.dataMap = dataMap;
+        this.populateVariables();
+        this.populateOptions();
+        this.populateConditions();
+    }
+    getData() {
+        return this.data;
+    }
+    populateConditions() {
+        for (let i = 0; i < this.dataMap.c.s.length; i += 1) {
+            const sectionId = this.dataMap.c.s[i];
+            const sectionCondition = selectSectionConditionValue(sectionId);
+            this.data.c.s[sectionId] = [sectionCondition !== false];
+        }
+        for (let i = 0; i < this.dataMap.c.o.length; i += 1) {
+            const optionId = this.dataMap.c.o[i];
+            const optionCondition = [...this.getOptionConditions(optionId)];
+            this.data.c.o[optionId] =
+                optionCondition === undefined ? [false] : optionCondition;
+        }
+        for (let i = 0; i < this.dataMap.c.v.length; i += 1) {
+            const variableId = this.dataMap.c.v[i];
+            const variableCondition = [...this.getVariablesConditions(variableId)];
+            this.data.c.v[variableId] =
+                variableCondition === undefined ? [false] : variableCondition;
+        }
+    }
+    getOptionConditions(optionId) {
+        const conditions = selectOptionConditionValue(optionId);
+        if (conditions === undefined)
+            return [true];
+        if (this.id === undefined || this.index === undefined) {
+            return conditions;
+        }
+        const optionRootParent = this.getOptionRootParent(optionId);
+        const optionRootRelations = selectOptionRelations(optionRootParent);
+        if (optionRootRelations.children.options.includes(this.id) ||
+            optionRootRelations.dependants.includes(this.id) ||
+            this.id === optionRootParent) {
+            if (conditions !== undefined && conditions[this.index] === false)
+                return [false];
+            return [conditions[this.index]];
+        }
+        return conditions;
+    }
+    getVariablesConditions(variableId) {
+        const conditions = selectVariableConditionValue(variableId);
+        if (conditions === undefined)
+            return [true];
+        if (this.id === undefined || this.index === undefined) {
+            return conditions;
+        }
+        const variableRootParent = this.getVariableRootParent(variableId);
+        const variableRootRelations = selectOptionRelations(variableRootParent);
+        if (variableRootRelations.children.options.includes(this.id) ||
+            variableRootRelations.dependants.includes(this.id) ||
+            this.id === variableRootParent) {
+            return [conditions[this.index]];
+        }
+        return conditions;
+    }
+    populateVariables() {
+        for (let i = 0; i < this.dataMap.v.length; i += 1) {
+            const variableId = this.dataMap.v[i];
+            const variableReference = selectVariableReference(variableId);
+            let values = this.getVariableValues(variableId);
+            if (variableReference.type === 'number') {
+                values = values
+                    .map((v) => (typeof v === 'number' ? v : parseFloat(v)))
+                    .map((v) => (Number.isNaN(v) ? '' : v));
+            }
+            this.data.v[variableId] = [...values];
+        }
+    }
+    getVariableValues(variableId) {
+        const value = selectVariableInput(variableId);
+        if (this.id === undefined || this.index === undefined) {
+            return value;
+        }
+        const variableRootParent = this.getVariableRootParent(variableId);
+        const variableRootRelations = selectOptionRelations(variableRootParent);
+        if (variableRootRelations.children.options.includes(this.id) ||
+            variableRootRelations.dependants.includes(this.id) ||
+            this.id === variableRootParent) {
+            return [value[this.index]];
+        }
+        return this.cleanArrayFromNullValues([...value]);
+    }
+    getVariableRootParent(variableId) {
+        const variableParents = selectVariableParents(variableId);
+        return variableParents[variableParents.length - 1];
+    }
+    cleanArrayFromNullValues(arr) {
+        return arr.map((v) => (v === null ? '' : v));
+    }
+    populateOptions() {
+        for (let i = 0; i < this.dataMap.o.length; i += 1) {
+            const optionId = this.dataMap.o[i];
+            const inputs = this.getOptionInputs(optionId);
+            this.data.o[optionId] = [...inputs];
+        }
+    }
+    getOptionInputs(optionId) {
+        const inputs = selectOptionInput(optionId);
+        if (this.id === undefined || this.index === undefined) {
+            return inputs;
+        }
+        const optionRootParent = this.getOptionRootParent(optionId);
+        const optionRootRelations = selectOptionRelations(optionRootParent);
+        if (optionRootRelations.children.options.includes(this.id) ||
+            optionRootRelations.dependants.includes(this.id) ||
+            this.id === optionRootParent) {
+            return [inputs[this.index]];
+        }
+        return inputs;
+    }
+    getOptionRootParent(optionId) {
+        const optionParents = selectOptionParents(optionId);
+        return optionParents.length > 0
+            ? optionParents[optionParents.length - 1]
+            : optionId;
+    }
+}
+export default DataPopulator;

package/dist/libs/ConditionsRunner.d.ts

@@ -0,0 +1,17 @@
+import { Dispatch } from 'redux';
+import { 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 declare class ConditionsRunner {
+    dispatch: Dispatch;
+    constructor(dispatch: Dispatch);
+    shouldConditionUpdate(oldCondition: AllConditions, newCondition: AllConditions): boolean;
+    isOptionRelatedToOption(optionA: number, optionB: number): boolean;
+    isVariableRelatedToOption(variableId: number, optionId: number): boolean;
+    isVariableRelatedToVariable(variableA: number, variableB: number): boolean;
+    getInputsForOption(optionId: number): number[];
+    getInputsForVariable(variableId: number): number[];
+    executeHooks(type: 'variables' | 'options' | 'sections', id: number, index: number): void;
+    executeSectionsHooks(hooks: any, index: number): void;
+    executeCondition(condition: MAPPED_CONDITIONS | MAPPED_CONDITIONS[], id: number, index: number, conditionType: string): any;
+    executeRawCondition(condition: MAPPED_CONDITIONS | MAPPED_CONDITIONS[]): any;
+}