@legalplace/conditions-runner 2.2.20 → 2.3.1

package/CHANGELOG.md

@@ -3,6 +3,34 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.3.1](https://git.legalplace.eu/legalplace/monorepo/compare/@legalplace/conditions-runner@2.3.0...@legalplace/conditions-runner@2.3.1) (2026-09-01)
+
+
+### Bug Fixes
+
+* prevent LpLogic cleanString crash on null related-row values ([c07292d](https://git.legalplace.eu/legalplace/monorepo/commits/c07292d1ccdb615ee4ab885cafea10d6b08f479e))
+
+
+
+
+
+# [2.3.0](https://git.legalplace.eu/legalplace/monorepo/compare/@legalplace/conditions-runner@2.2.20...@legalplace/conditions-runner@2.3.0) (2026-09-01)
+
+
+### Bug Fixes
+
+* fix conditions on multiples and repeated outputs ([d77efbe](https://git.legalplace.eu/legalplace/monorepo/commits/d77efbe706da435c6e853176432f64954217d046))
+* update InputsType import to align with new module structure ([61b0b47](https://git.legalplace.eu/legalplace/monorepo/commits/61b0b473168e298ded44eeeb7d041a52608dc038))
+
+
+### Features
+
+* output image assets, documentStyle font sizes and table column widths ([8dfb115](https://git.legalplace.eu/legalplace/monorepo/commits/8dfb115d74cd3e5acbb11dd798efa749a8098001))
+
+
+
+
+
 ## [2.2.20](https://git.legalplace.eu/legalplace/monorepo/compare/@legalplace/conditions-runner@2.2.19...@legalplace/conditions-runner@2.2.20) (2026-08-27)
 
 **Note:** Version bump only for package @legalplace/conditions-runner

package/dist/ComparatorResolver.d.ts

@@ -0,0 +1,22 @@
+import type { Types } from "@legalplace/referencesparser";
+import type { InputsType } from "@legalplace/types";
+export declare const CONDITION_COMPARATOR_EMPTY_SENTINEL = "\uE000__LP_EMPTY__\uE000";
+export declare const SCOPED_OPERATOR_REGEX: RegExp;
+export type ComparatorResolverContext = {
+    optionId: number;
+    index: number;
+    conditionVariableId?: number;
+    conditionOptionId?: number;
+    evalVariableId?: number;
+};
+export type ComparatorResolverDeps = {
+    references: Types.ReferencesType;
+    ovc: InputsType;
+};
+export declare const getConditionVariableOptionId: (references: Types.ReferencesType, variableId: number) => number;
+export declare const extractVarTagIds: (text: string) => number[];
+export declare const extractLhsVariableId: (lhs: unknown) => number | undefined;
+export declare const areVariablesSiblings: (references: Types.ReferencesType, variableA: number, variableB: number) => boolean;
+export declare const parseConditionComparatorWithVariables: (text: string, optionId: number, index: number, deps: ComparatorResolverDeps, context?: Pick<ComparatorResolverContext, "conditionVariableId" | "conditionOptionId" | "evalVariableId">) => string;
+export declare const resolveComparatorString: (value: string, context: ComparatorResolverContext, deps: ComparatorResolverDeps) => string;
+export declare const resolveConditionComparators: (conditions: unknown, context: ComparatorResolverContext, deps: ComparatorResolverDeps) => unknown;

package/dist/ComparatorResolver.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConditionComparators = exports.resolveComparatorString = exports.parseConditionComparatorWithVariables = exports.areVariablesSiblings = exports.extractLhsVariableId = exports.extractVarTagIds = exports.getConditionVariableOptionId = exports.SCOPED_OPERATOR_REGEX = exports.CONDITION_COMPARATOR_EMPTY_SENTINEL = void 0;
+const referencesparser_1 = require("@legalplace/referencesparser");
+exports.CONDITION_COMPARATOR_EMPTY_SENTINEL = "\uE000__LP_EMPTY__\uE000";
+const VAR_TAG_IN_TEXT_REGEX = /\[var:[0-9]+\]/i;
+const UI_METADATA_KEYS = new Set(["scope", "groupMeta"]);
+const RECOGNIZED_OPERATOR_KEYS = new Set((0, referencesparser_1.getRecognizedOperatorKeys)());
+exports.SCOPED_OPERATOR_REGEX = /-(first|any)$/;
+const getConditionVariableOptionId = (references, variableId) => {
+    var _a;
+    const parents = (_a = references.relations.variables[variableId]) === null || _a === void 0 ? void 0 : _a.parents;
+    return parents !== undefined && parents.length > 0 ? parents[0] : variableId;
+};
+exports.getConditionVariableOptionId = getConditionVariableOptionId;
+const extractVarTagIds = (text) => {
+    const tagsMatch = text.match(/\[var:([0-9]+)\]/gi);
+    if (tagsMatch === null)
+        return [];
+    return [
+        ...new Set(tagsMatch.map((tag) => {
+            const match = tag.match(/([0-9]+)/);
+            return match === null ? 0 : parseInt(match[0], 10);
+        })),
+    ];
+};
+exports.extractVarTagIds = extractVarTagIds;
+const extractLhsVariableId = (lhs) => {
+    if (typeof lhs !== "object" ||
+        lhs === null ||
+        !("var" in lhs) ||
+        typeof lhs.var !== "string") {
+        return undefined;
+    }
+    const match = lhs.var.match(/^v\.([0-9]+)$/);
+    return match === null ? undefined : parseInt(match[1], 10);
+};
+exports.extractLhsVariableId = extractLhsVariableId;
+const areVariablesSiblings = (references, variableA, variableB) => {
+    var _a, _b, _c, _d;
+    const rootA = (_b = (_a = references.relations.variables[variableA]) === null || _a === void 0 ? void 0 : _a.parents) === null || _b === void 0 ? void 0 : _b.slice(-1)[0];
+    const rootB = (_d = (_c = references.relations.variables[variableB]) === null || _c === void 0 ? void 0 : _c.parents) === null || _d === void 0 ? void 0 : _d.slice(-1)[0];
+    return rootA !== undefined && rootA === rootB;
+};
+exports.areVariablesSiblings = areVariablesSiblings;
+const shouldUseConditionRowIndex = (references, variableId, optionId, context) => {
+    var _a, _b;
+    const contextVariableId = context === null || context === void 0 ? void 0 : context.contextVariableId;
+    if (contextVariableId !== undefined &&
+        (0, exports.areVariablesSiblings)(references, variableId, contextVariableId)) {
+        return true;
+    }
+    if ((context === null || context === void 0 ? void 0 : context.conditionOptionId) !== undefined) {
+        const parents = (_a = references.relations.variables[variableId]) === null || _a === void 0 ? void 0 : _a.parents;
+        if (parents !== undefined &&
+            parents.length > 0 &&
+            parents[0] === context.conditionOptionId) {
+            return true;
+        }
+    }
+    const variableParents = (_b = references.relations.variables[variableId]) === null || _b === void 0 ? void 0 : _b.parents;
+    if (variableParents === undefined || variableParents.length === 0) {
+        return false;
+    }
+    const rootVariableParentId = variableParents[variableParents.length - 1];
+    const rootVariableParentRelations = references.relations.options[rootVariableParentId];
+    if (rootVariableParentRelations === undefined)
+        return false;
+    return (rootVariableParentRelations.children.options.includes(optionId) ||
+        rootVariableParentRelations.dependants.includes(optionId) ||
+        optionId === rootVariableParentId);
+};
+const normalizeConditionValue = (currentValue) => {
+    if (currentValue === null || currentValue === undefined)
+        return "";
+    if (typeof currentValue === "number")
+        return currentValue.toString();
+    if (typeof currentValue === "string")
+        return currentValue;
+    return "";
+};
+const parseConditionComparatorWithVariables = (text, optionId, index, deps, context) => {
+    var _a;
+    const variableIds = (0, exports.extractVarTagIds)(text);
+    if (variableIds.length === 0)
+        return text;
+    const rowContext = {
+        contextVariableId: (_a = context === null || context === void 0 ? void 0 : context.evalVariableId) !== null && _a !== void 0 ? _a : context === null || context === void 0 ? void 0 : context.conditionVariableId,
+        conditionOptionId: context === null || context === void 0 ? void 0 : context.conditionOptionId,
+    };
+    let parsedText = text;
+    variableIds.forEach((variableId) => {
+        var _a;
+        const values = (_a = deps.ovc.variables[variableId]) !== null && _a !== void 0 ? _a : [];
+        const useRow = shouldUseConditionRowIndex(deps.references, variableId, optionId, rowContext);
+        const cleanValues = useRow
+            ? [normalizeConditionValue(values[index])]
+            : values.map((value) => normalizeConditionValue(value));
+        let resolved = cleanValues.length === 1 ? cleanValues[0] : cleanValues.join(", ");
+        if (resolved.trim().length === 0) {
+            resolved = exports.CONDITION_COMPARATOR_EMPTY_SENTINEL;
+        }
+        parsedText = parsedText.replace(new RegExp(`\\[var:${variableId}\\]`, "gi"), resolved);
+    });
+    return parsedText;
+};
+exports.parseConditionComparatorWithVariables = parseConditionComparatorWithVariables;
+const resolveLeafContext = (lhs, context, deps) => {
+    const variableId = (0, exports.extractLhsVariableId)(lhs);
+    if (variableId === undefined)
+        return context;
+    return {
+        ...context,
+        optionId: (0, exports.getConditionVariableOptionId)(deps.references, variableId),
+        evalVariableId: variableId,
+    };
+};
+const resolveComparatorString = (value, context, deps) => {
+    if (!VAR_TAG_IN_TEXT_REGEX.test(value))
+        return value;
+    return (0, exports.parseConditionComparatorWithVariables)(value, context.optionId, context.index, deps, {
+        evalVariableId: context.evalVariableId,
+        conditionVariableId: context.conditionVariableId,
+        conditionOptionId: context.conditionOptionId,
+    });
+};
+exports.resolveComparatorString = resolveComparatorString;
+const walkConditionNode = (node, context, deps) => {
+    if (node === null || node === undefined)
+        return node;
+    if (Array.isArray(node)) {
+        return node.map((child) => walkConditionNode(child, context, deps));
+    }
+    if (typeof node !== "object")
+        return node;
+    const conditionNode = node;
+    const structuralKeys = Object.keys(conditionNode).filter((key) => !UI_METADATA_KEYS.has(key));
+    if (structuralKeys.length === 0)
+        return conditionNode;
+    const operatorKey = structuralKeys.find((key) => RECOGNIZED_OPERATOR_KEYS.has(key));
+    if (structuralKeys.length > 1 && operatorKey === undefined) {
+        return conditionNode;
+    }
+    const currentKey = operatorKey !== null && operatorKey !== void 0 ? operatorKey : structuralKeys[0];
+    if (currentKey === "and" || currentKey === "or") {
+        const children = conditionNode[currentKey];
+        if (!Array.isArray(children))
+            return conditionNode;
+        return {
+            ...conditionNode,
+            [currentKey]: children.map((child) => walkConditionNode(child, context, deps)),
+        };
+    }
+    if (RECOGNIZED_OPERATOR_KEYS.has(currentKey)) {
+        const args = conditionNode[currentKey];
+        if (!Array.isArray(args) || args.length < 2)
+            return conditionNode;
+        const resolvedArgs = [...args];
+        const comparator = resolvedArgs[1];
+        if (typeof comparator === "string") {
+            const baseContext = exports.SCOPED_OPERATOR_REGEX.test(currentKey)
+                ? { ...context, index: 0 }
+                : context;
+            const leafContext = resolveLeafContext(resolvedArgs[0], baseContext, deps);
+            resolvedArgs[1] = (0, exports.resolveComparatorString)(comparator, leafContext, deps);
+        }
+        return {
+            ...conditionNode,
+            [currentKey]: resolvedArgs,
+        };
+    }
+    return conditionNode;
+};
+const resolveConditionComparators = (conditions, context, deps) => {
+    if (Array.isArray(conditions)) {
+        return conditions.map((condition) => walkConditionNode(condition, context, deps));
+    }
+    return walkConditionNode(conditions, context, deps);
+};
+exports.resolveConditionComparators = resolveConditionComparators;

package/dist/ConditionsRunner.d.ts

@@ -15,5 +15,6 @@ declare class ConditionsRunner {
         dataMap: ConditionDataMap;
         conditions: ConditionV3;
     }, id: number, index: number, conditionType: "options" | "optionValidator" | "variables" | "prefillers" | "variableValidator" | "sections" | "documents"): any;
+    private buildComparatorResolverContext;
 }
 export default ConditionsRunner;

package/dist/ConditionsRunner.js

@@ -4,7 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const lplogic_1 = __importDefault(require("@legalplace/lplogic"));
+const referencesparser_1 = require("@legalplace/referencesparser");
 const DataPopulator_1 = __importDefault(require("./DataPopulator"));
+const ScopedLeafEvaluator_1 = require("./ScopedLeafEvaluator");
+const ComparatorResolver_1 = require("./ComparatorResolver");
 class ConditionsRunner {
     constructor(references, ovc) {
         this.executeConditionMemo = {};
@@ -77,9 +80,28 @@ class ConditionsRunner {
         else if (conditionType === "sections" || conditionType === "documents") {
             currentData = new DataPopulator_1.default(this, this.references, this.ovc, condition.dataMap, id, index).getData();
         }
-        const result = (0, lplogic_1.default)(condition.conditions, currentData);
+        const resolverContext = this.buildComparatorResolverContext(id, index, conditionType);
+        const deps = { references: this.references, ovc: this.ovc };
+        const aggregatedConditions = (0, ScopedLeafEvaluator_1.aggregateScopedLeaves)((0, referencesparser_1.lowerScope)(condition.conditions), new DataPopulator_1.default(this, this.references, this.ovc, condition.dataMap).getData(), resolverContext, deps);
+        const resolvedConditions = (0, ComparatorResolver_1.resolveConditionComparators)(aggregatedConditions, resolverContext, deps);
+        const result = (0, lplogic_1.default)(resolvedConditions, currentData);
         this.executeConditionMemo[memoizedKey] = result;
         return result;
     }
+    buildComparatorResolverContext(id, index, conditionType) {
+        if (conditionType === "options" || conditionType === "optionValidator") {
+            return { optionId: id, index, conditionOptionId: id };
+        }
+        if (conditionType === "variables" ||
+            conditionType === "prefillers" ||
+            conditionType === "variableValidator") {
+            return {
+                optionId: (0, ComparatorResolver_1.getConditionVariableOptionId)(this.references, id),
+                index,
+                conditionVariableId: id,
+            };
+        }
+        return { optionId: id, index };
+    }
 }
 exports.default = ConditionsRunner;

package/dist/ConditionsRunner.test.js

@@ -3,11 +3,292 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const referencesparser_1 = require("@legalplace/referencesparser");
 const ConditionsRunner_1 = __importDefault(require("./ConditionsRunner"));
+const ComparatorResolver_1 = require("./ComparatorResolver");
 const inputs_type_json_1 = __importDefault(require("./fixtures/inputs-type.json"));
 const references_json_1 = __importDefault(require("./fixtures/references.json"));
+const emptyOptionRelations = {
+    options: [],
+    variables: [],
+    sections: {},
+    documents: [],
+    prefillers: [],
+    validators: { options: [], variables: [] },
+    parents: [],
+    children: { options: [], variables: [] },
+    dependants: [],
+};
+const buildRelatedDocumentReferences = () => ({
+    options: {
+        2: {
+            meta: {
+                id: 2,
+                type: "static",
+                label: "Partner",
+                step: "*",
+                multiple: { enabled: true },
+            },
+            options: [3, 4],
+            variables: [],
+        },
+        3: {
+            meta: { id: 3, type: "radio", label: "Yes", step: "*" },
+            options: [],
+            variables: [],
+        },
+        4: {
+            meta: { id: 4, type: "radio", label: "No", step: "*" },
+            options: [],
+            variables: [],
+        },
+    },
+    variables: {},
+    outputs: {},
+    boxes: {},
+    documents: {
+        annex: {
+            name: "Annex",
+            params: { multiple: { enabled: true, repeatOption: 2 } },
+        },
+    },
+    sections: {},
+    relations: {
+        options: {
+            2: {
+                ...emptyOptionRelations,
+                children: { options: [3, 4], variables: [] },
+            },
+            3: { ...emptyOptionRelations, parents: [2] },
+            4: { ...emptyOptionRelations, parents: [2] },
+        },
+        variables: {},
+        sections: {},
+    },
+    conditions: {
+        options: {},
+        variables: {},
+        documents: {},
+        sections: { main: {} },
+        prefillers: {},
+        validators: { options: {}, variables: {} },
+    },
+    defaults: {},
+    evaluations: {},
+    optionTags: {},
+    variableTags: {},
+});
+const buildSiblingVariableReferences = () => ({
+    options: {
+        10: {
+            meta: {
+                id: 10,
+                type: "static",
+                label: "Repeat",
+                step: "*",
+                multiple: { enabled: true },
+            },
+            options: [],
+            variables: [3, 4],
+        },
+        20: {
+            meta: { id: 20, type: "static", label: "Other", step: "*" },
+            options: [],
+            variables: [5],
+        },
+    },
+    variables: {
+        3: { meta: { id: 3, type: "string", label: "Left" }, options: [] },
+        4: { meta: { id: 4, type: "string", label: "Right" }, options: [] },
+        5: { meta: { id: 5, type: "string", label: "Elsewhere" }, options: [] },
+    },
+    outputs: {},
+    boxes: {},
+    documents: {},
+    sections: {},
+    relations: {
+        options: {
+            10: {
+                ...emptyOptionRelations,
+                children: { options: [], variables: [3, 4] },
+            },
+            20: {
+                ...emptyOptionRelations,
+                children: { options: [], variables: [5] },
+            },
+        },
+        variables: {
+            3: { ...emptyOptionRelations, parents: [10] },
+            4: { ...emptyOptionRelations, parents: [10] },
+            5: { ...emptyOptionRelations, parents: [20] },
+        },
+        sections: {},
+    },
+    conditions: {
+        options: {},
+        variables: {},
+        documents: {},
+        sections: { main: {} },
+        prefillers: {},
+        validators: { options: {}, variables: {} },
+    },
+    defaults: {},
+    evaluations: {},
+    optionTags: {},
+    variableTags: {},
+});
+const relatedOvc = {
+    options: {
+        2: [true, true],
+        3: [true, false],
+        4: [false, true],
+    },
+    variables: {},
+};
+const siblingOvc = {
+    options: {
+        10: [true, true, true],
+        20: [true],
+    },
+    variables: {
+        3: ["same", "b", "c"],
+        4: ["same", "y", "c"],
+        5: ["solo-a", "solo-b"],
+    },
+};
+const mappedCondition = (conditions) => ({
+    dataMap: (0, referencesparser_1.extractConditionDataMap)(conditions),
+    conditions,
+});
 describe("ConditionsRunner class", () => {
     it("should not raise error when instanciating class", () => {
         expect(new ConditionsRunner_1.default(references_json_1.default, inputs_type_json_1.default)).toBeDefined();
     });
+    it("slices related document conditions to the current occurrence", () => {
+        const runner = new ConditionsRunner_1.default(buildRelatedDocumentReferences(), relatedOvc);
+        const condition = mappedCondition({
+            selected: [{ var: "o.3" }],
+            scope: "related",
+        });
+        expect(runner.executeCondition(condition, 2, 0, "documents")).toBe(true);
+        expect(runner.executeCondition(condition, 2, 1, "documents")).toBe(false);
+    });
+    it("evaluates selected + first against the first row after id/index slicing", () => {
+        const runner = new ConditionsRunner_1.default(buildRelatedDocumentReferences(), relatedOvc);
+        const condition = mappedCondition({
+            selected: [{ var: "o.3" }],
+            scope: "first",
+        });
+        expect(runner.executeCondition(condition, 2, 1, "documents")).toBe(true);
+    });
+    it("related sibling [var:N] uses the current occurrence index", () => {
+        const runner = new ConditionsRunner_1.default(buildSiblingVariableReferences(), siblingOvc);
+        const condition = mappedCondition({
+            "=": [{ var: "v.3" }, "[var:4]"],
+            scope: "related",
+        });
+        expect(runner.executeCondition(condition, 3, 0, "variables")).toBe(true);
+        expect(runner.executeCondition(condition, 3, 1, "variables")).toBe(false);
+        expect(runner.executeCondition(condition, 3, 2, "variables")).toBe(true);
+    });
+    it("first-scoped sibling [var:N] uses occurrence 0", () => {
+        const runner = new ConditionsRunner_1.default(buildSiblingVariableReferences(), siblingOvc);
+        const condition = mappedCondition({
+            "=": [{ var: "v.3" }, "[var:4]"],
+            scope: "first",
+        });
+        expect(runner.executeCondition(condition, 3, 2, "variables")).toBe(true);
+    });
+    it("all-scope sibling [var:N] is pairwise true when every row matches", () => {
+        const runner = new ConditionsRunner_1.default(buildSiblingVariableReferences(), {
+            options: { 10: [true, true], 20: [true] },
+            variables: {
+                3: [1, 2],
+                4: [2, 3],
+                5: ["solo-a"],
+            },
+        });
+        const condition = mappedCondition({
+            "<": [{ var: "v.3" }, "[var:4]"],
+            scope: "all",
+        });
+        expect(runner.executeCondition(condition, 3, 0, "options")).toBe(true);
+    });
+    it("all-scope sibling [var:N] is pairwise false when a row fails", () => {
+        const runner = new ConditionsRunner_1.default(buildSiblingVariableReferences(), {
+            options: { 10: [true, true], 20: [true] },
+            variables: {
+                3: [1, 5],
+                4: [2, 3],
+                5: ["solo-a"],
+            },
+        });
+        const condition = mappedCondition({
+            "<": [{ var: "v.3" }, "[var:4]"],
+            scope: "all",
+        });
+        expect(runner.executeCondition(condition, 3, 0, "options")).toBe(false);
+    });
+    it("any-scope sibling [var:N] succeeds on a later pairwise row", () => {
+        const runner = new ConditionsRunner_1.default(buildSiblingVariableReferences(), {
+            options: { 10: [true, true], 20: [true] },
+            variables: {
+                3: [5, 1],
+                4: [2, 10],
+                5: ["solo-a"],
+            },
+        });
+        const condition = mappedCondition({
+            "<": [{ var: "v.3" }, "[var:4]"],
+            scope: "any",
+        });
+        expect(runner.executeCondition(condition, 5, 0, "options")).toBe(true);
+    });
+    it("joins non-sibling [var:N] values instead of slicing by row", () => {
+        const references = buildSiblingVariableReferences();
+        const resolved = (0, ComparatorResolver_1.resolveConditionComparators)((0, referencesparser_1.lowerScope)({
+            "=": [{ var: "v.3" }, "[var:5]"],
+            scope: "related",
+        }), { optionId: 10, index: 2, conditionVariableId: 3 }, { references, ovc: siblingOvc });
+        expect(resolved).toEqual({
+            "=": [{ var: "v.3" }, "solo-a, solo-b"],
+        });
+    });
+});
+describe("resolveConditionComparators", () => {
+    const references = buildSiblingVariableReferences();
+    const deps = { references, ovc: siblingOvc };
+    it("related leaf: sibling [var:N] uses the current occurrence index", () => {
+        const resolved = (0, ComparatorResolver_1.resolveConditionComparators)((0, referencesparser_1.lowerScope)({
+            "=": [{ var: "v.3" }, "[var:4]"],
+            scope: "related",
+        }), { optionId: 10, index: 2, conditionVariableId: 3 }, deps);
+        expect(resolved).toEqual({
+            "=": [{ var: "v.3" }, "c"],
+        });
+    });
+    it("first-scoped leaf: sibling [var:N] uses occurrence 0", () => {
+        const resolved = (0, ComparatorResolver_1.resolveConditionComparators)((0, referencesparser_1.lowerScope)({
+            "=": [{ var: "v.3" }, "[var:4]"],
+            scope: "first",
+        }), { optionId: 10, index: 2, conditionVariableId: 3 }, deps);
+        expect(resolved).toEqual({
+            "=-first": [{ var: "v.3" }, "same"],
+        });
+    });
+    it("uses empty sentinel for missing sibling values", () => {
+        const resolved = (0, ComparatorResolver_1.resolveConditionComparators)((0, referencesparser_1.lowerScope)({
+            "=": [{ var: "v.3" }, "[var:4]"],
+            scope: "related",
+        }), { optionId: 10, index: 5, conditionVariableId: 3 }, {
+            references,
+            ovc: {
+                options: siblingOvc.options,
+                variables: { 3: ["a"], 4: ["b"], 5: [] },
+            },
+        });
+        expect(resolved).toEqual({
+            "=": [{ var: "v.3" }, ComparatorResolver_1.CONDITION_COMPARATOR_EMPTY_SENTINEL],
+        });
+    });
 });

package/dist/DataPopulator.js

@@ -95,14 +95,14 @@ class DataPopulator {
     getVariableValues(variableId) {
         const value = this.ovc.variables[variableId] || [];
         if (this.id === undefined || this.index === undefined) {
-            return value;
+            return this.cleanArrayFromNullValues([...value]);
         }
         const variableRootParent = this.getVariableRootParent(variableId);
         const variableRootRelations = this.references.relations.options[variableRootParent];
         if (variableRootRelations.children.options.includes(this.id) ||
             variableRootRelations.dependants.includes(this.id) ||
             this.id === variableRootParent) {
-            return [value[this.index]];
+            return this.cleanArrayFromNullValues([value[this.index]]);
         }
         return this.cleanArrayFromNullValues([...value]);
     }
@@ -111,7 +111,7 @@ class DataPopulator {
         return variableParents[variableParents.length - 1];
     }
     cleanArrayFromNullValues(arr) {
-        return arr.map((v) => (v === null ? "" : v));
+        return arr.map((v) => (v === null || v === undefined ? "" : v));
     }
     populateOptions() {
         for (let i = 0; i < this.dataMap.o.length; i += 1) {

package/dist/ScopedLeafEvaluator.d.ts

@@ -0,0 +1,3 @@
+import type { ConditionData } from "./types/conditions.d";
+import { type ComparatorResolverContext, type ComparatorResolverDeps } from "./ComparatorResolver";
+export declare const aggregateScopedLeaves: (tree: unknown, unslicedData: ConditionData, context: ComparatorResolverContext, deps: ComparatorResolverDeps) => unknown;