@inseefr/lunatic 3.0.0-rc.9 → 3.0.1-rc.0

package/lib/use-lunatic/commons/variables/lunatic-variables-store.spec.js

@@ -1,397 +1,369 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _cleaningBehaviour = require("./behaviours/cleaning-behaviour");
-var _missingBehaviour = require("./behaviours/missing-behaviour");
-var _resizingBehaviour = require("./behaviours/resizing-behaviour");
-var _lunaticVariablesStore = require("./lunatic-variables-store");
-(0, _vitest.describe)('lunatic-variables-store', function () {
-  var variables;
-  (0, _vitest.beforeEach)(function () {
-    variables = new _lunaticVariablesStore.LunaticVariablesStore();
-  });
-  (0, _vitest.it)('should record basic variables', function () {
-    variables.set('FIRSTNAME', 'John');
-    (0, _vitest.expect)(variables.get('FIRSTNAME')).toEqual('John');
-  });
-  (0, _vitest.it)('should handle array correctly', function () {
-    variables.set('AGE', [10, 20, 30]);
-    (0, _vitest.expect)(variables.get('AGE')).toEqual([10, 20, 30]);
-    variables.set('AGE', [10, 20]);
-    (0, _vitest.expect)(variables.get('AGE')).toEqual([10, 20]);
-  });
-  (0, _vitest.it)('should create a store from an object', function () {
-    var store = _lunaticVariablesStore.LunaticVariablesStore.makeFromObject({
-      name: 'John',
-      lastname: 'Doe'
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { cleaningBehaviour } from './behaviours/cleaning-behaviour';
+import { missingBehaviour } from './behaviours/missing-behaviour';
+import { resizingBehaviour } from './behaviours/resizing-behaviour';
+import { LunaticVariablesStore } from './lunatic-variables-store';
+describe('lunatic-variables-store', () => {
+    let variables;
+    beforeEach(() => {
+        variables = new LunaticVariablesStore();
     });
-    (0, _vitest.expect)(store.get('name')).toEqual('John');
-    (0, _vitest.expect)(store.get('lastname')).toEqual('Doe');
-  });
-  (0, _vitest.it)('should run with simple types', function () {
-    (0, _vitest.expect)(variables.run('"Hello world"')).toEqual('Hello world');
-    (0, _vitest.expect)(variables.run('true')).toEqual(true);
-    (0, _vitest.expect)(variables.run('2')).toEqual(2);
-  });
-  (0, _vitest.it)('should handle calculated', function () {
-    variables.set('FIRSTNAME', 'John');
-    variables.set('LASTNAME', 'Doe');
-    variables.setCalculated('FULLNAME', 'FIRSTNAME || " " || LASTNAME', {
-      dependencies: ['FIRSTNAME', 'LASTNAME'],
-      shapeFrom: 'FIRSTNAME'
+    it('should record basic variables', () => {
+        variables.set('FIRSTNAME', 'John');
+        expect(variables.get('FIRSTNAME')).toEqual('John');
     });
-    (0, _vitest.expect)(variables.get('FULLNAME')).toEqual('John Doe');
-    (0, _vitest.expect)(variables.interpretCount).toBe(1);
-    // The result should be cached
-    (0, _vitest.expect)(variables.get('FULLNAME')).toEqual('John Doe');
-    (0, _vitest.expect)(variables.interpretCount).toBe(1);
-    // But refreshed if a variable was updated
-    variables.set('FIRSTNAME', 'Jane');
-    (0, _vitest.expect)(variables.get('FULLNAME')).toEqual('Jane Doe');
-    (0, _vitest.expect)(variables.interpretCount).toBe(2);
-  });
-  (0, _vitest.it)('should handle deep calculation', function () {
-    variables.set('FIRSTNAME', 'John');
-    variables.set('LASTNAME', 'Doe');
-    variables.set('AGE', '18');
-    variables.setCalculated('FULLNAME', 'FIRSTNAME || " " || LASTNAME', {
-      dependencies: ['FIRSTNAME', 'LASTNAME'],
-      shapeFrom: 'FIRSTNAME'
+    it('should handle array correctly', () => {
+        variables.set('AGE', [10, 20, 30]);
+        expect(variables.get('AGE')).toEqual([10, 20, 30]);
+        variables.set('AGE', [10, 20]);
+        expect(variables.get('AGE')).toEqual([10, 20]);
     });
-    variables.setCalculated('LABEL', 'FULLNAME || " is " || AGE', {
-      dependencies: ['FULLNAME', 'AGE'],
-      shapeFrom: 'FULLNAME'
+    it('should create a store from an object', () => {
+        const store = LunaticVariablesStore.makeFromObject({
+            name: 'John',
+            lastname: 'Doe',
+        });
+        expect(store.get('name')).toEqual('John');
+        expect(store.get('lastname')).toEqual('Doe');
     });
-    (0, _vitest.expect)(variables.get('LABEL')).toEqual('John Doe is 18');
-    (0, _vitest.expect)(variables.interpretCount).toBe(2);
-    variables.set('AGE', '20');
-    (0, _vitest.expect)(variables.get('LABEL')).toEqual('John Doe is 20');
-    (0, _vitest.expect)(variables.interpretCount).toBe(3);
-    variables.set('FIRSTNAME', 'Jane');
-    (0, _vitest.expect)(variables.get('LABEL')).toEqual('Jane Doe is 20');
-    (0, _vitest.expect)(variables.interpretCount).toBe(5);
-    variables.get('LABEL');
-    (0, _vitest.expect)(variables.interpretCount).toBe(5);
-  });
-  (0, _vitest.it)('should handle dependencies resolution', function () {
-    variables.set('FIRSTNAME', 'John');
-    variables.set('LASTNAME', 'Doe');
-    variables.setCalculated('FULLNAME', 'FIRSTNAME || " " || LASTNAME');
-    (0, _vitest.expect)(variables.get('FULLNAME')).toEqual('John Doe');
-    variables.set('FIRSTNAME', 'Jane');
-    (0, _vitest.expect)(variables.get('FULLNAME')).toEqual('Jane Doe');
-  });
-  (0, _vitest.it)('should run expression on the fly', function () {
-    variables.set('FIRSTNAME', 'John');
-    variables.set('LASTNAME', 'Doe');
-    (0, _vitest.expect)(variables.run('FIRSTNAME || " " || LASTNAME')).toEqual('John Doe');
-    (0, _vitest.expect)(variables.run('FIRSTNAME || " " || LASTNAME')).toEqual('John Doe');
-    (0, _vitest.expect)(variables.interpretCount).toBe(2);
-    variables.set('FIRSTNAME', 'Jane');
-    (0, _vitest.expect)(variables.run('FIRSTNAME || " " || LASTNAME')).toEqual('Jane Doe');
-  });
-  (0, _vitest.it)('should throw an exception when calculated incorrect VTL', function () {
-    (0, _vitest.expect)(function () {
-      return variables.run('Hello world');
-    }).toThrowError();
-  });
-  (0, _vitest.describe)('event listener', function () {
-    (0, _vitest.it)('should trigger onChange', function () {
-      variables.set('FIRSTNAME', 'John');
-      var spy = _vitest.vi.fn();
-      variables.on('change', function (e) {
-        return spy(e.detail.name, e.detail.value);
-      });
-      variables.set('FIRSTNAME', 'Jane');
-      (0, _vitest.expect)(spy).toHaveBeenCalledWith('FIRSTNAME', 'Jane');
+    it('should run with simple types', () => {
+        expect(variables.run('"Hello world"')).toEqual('Hello world');
+        expect(variables.run('true')).toEqual(true);
+        expect(variables.run('2')).toEqual(2);
     });
-    (0, _vitest.it)('should trigger onChange on array', function () {
-      variables.set('AGE', [18, 23, 24]);
-      var spy = _vitest.vi.fn();
-      variables.on('change', function (e) {
-        return spy(e.detail.name, e.detail.value);
-      });
-      variables.set('AGE', [18, 23]);
-      (0, _vitest.expect)(spy).toHaveBeenCalledWith('AGE', [18, 23]);
-      variables.set('AGE', [18, 25]);
-      (0, _vitest.expect)(spy).toHaveBeenCalledWith('AGE', [18, 25]);
+    it('should handle calculated', () => {
+        variables.set('FIRSTNAME', 'John');
+        variables.set('LASTNAME', 'Doe');
+        variables.setCalculated('FULLNAME', 'FIRSTNAME || " " || LASTNAME', {
+            dependencies: ['FIRSTNAME', 'LASTNAME'],
+            shapeFrom: 'FIRSTNAME',
+        });
+        expect(variables.get('FULLNAME')).toEqual('John Doe');
+        expect(variables.interpretCount).toBe(1);
+        // The result should be cached
+        expect(variables.get('FULLNAME')).toEqual('John Doe');
+        expect(variables.interpretCount).toBe(1);
+        // But refreshed if a variable was updated
+        variables.set('FIRSTNAME', 'Jane');
+        expect(variables.get('FULLNAME')).toEqual('Jane Doe');
+        expect(variables.interpretCount).toBe(2);
     });
-    (0, _vitest.it)('should not trigger onChange when value does not change', function () {
-      variables.set('FIRSTNAME', 'John');
-      variables.set('AGE', [18, 20]);
-      var spy = _vitest.vi.fn();
-      variables.on('change', function (e) {
-        return spy(e.detail.name, e.detail.value);
-      });
-      variables.set('FIRSTNAME', 'John');
-      variables.set('AGE', [18, 20]);
-      (0, _vitest.expect)(spy).not.toHaveBeenCalled();
+    it('should handle deep calculation', () => {
+        variables.set('FIRSTNAME', 'John');
+        variables.set('LASTNAME', 'Doe');
+        variables.set('AGE', '18');
+        variables.setCalculated('FULLNAME', 'FIRSTNAME || " " || LASTNAME', {
+            dependencies: ['FIRSTNAME', 'LASTNAME'],
+            shapeFrom: 'FIRSTNAME',
+        });
+        variables.setCalculated('LABEL', 'FULLNAME || " is " || AGE', {
+            dependencies: ['FULLNAME', 'AGE'],
+            shapeFrom: 'FULLNAME',
+        });
+        expect(variables.get('LABEL')).toEqual('John Doe is 18');
+        expect(variables.interpretCount).toBe(2);
+        variables.set('AGE', '20');
+        expect(variables.get('LABEL')).toEqual('John Doe is 20');
+        expect(variables.interpretCount).toBe(3);
+        variables.set('FIRSTNAME', 'Jane');
+        expect(variables.get('LABEL')).toEqual('Jane Doe is 20');
+        expect(variables.interpretCount).toBe(5);
+        variables.get('LABEL');
+        expect(variables.interpretCount).toBe(5);
     });
-  });
-  (0, _vitest.describe)('with iteration', function () {
-    (0, _vitest.it)('should handle arrays', function () {
-      variables.set('FIRSTNAME', ['John', 'Jane']);
-      (0, _vitest.expect)(variables.get('FIRSTNAME')).toEqual(['John', 'Jane']);
-      (0, _vitest.expect)(variables.get('FIRSTNAME', [0])).toEqual('John');
-      (0, _vitest.expect)(variables.get('FIRSTNAME', [1])).toEqual('Jane');
+    it('should handle dependencies resolution', () => {
+        variables.set('FIRSTNAME', 'John');
+        variables.set('LASTNAME', 'Doe');
+        variables.setCalculated('FULLNAME', 'FIRSTNAME || " " || LASTNAME');
+        expect(variables.get('FULLNAME')).toEqual('John Doe');
+        variables.set('FIRSTNAME', 'Jane');
+        expect(variables.get('FULLNAME')).toEqual('Jane Doe');
     });
-    (0, _vitest.it)('should handle setting at a specific index', function () {
-      variables.set('FIRSTNAME', ['John', 'Jane']);
-      variables.set('LASTNAME', null);
-      variables.set('FIRSTNAME', 'Marc', {
-        iteration: [1]
-      });
-      (0, _vitest.expect)(variables.get('FIRSTNAME')).toEqual(['John', 'Marc']);
-      variables.set('LASTNAME', 'Doe', {
-        iteration: [1]
-      });
-      (0, _vitest.expect)(variables.get('LASTNAME')).toEqual([null, 'Doe']);
+    it('should run expression on the fly', () => {
+        variables.set('FIRSTNAME', 'John');
+        variables.set('LASTNAME', 'Doe');
+        expect(variables.run('FIRSTNAME || " " || LASTNAME')).toEqual('John Doe');
+        expect(variables.run('FIRSTNAME || " " || LASTNAME')).toEqual('John Doe');
+        expect(variables.interpretCount).toBe(2);
+        variables.set('FIRSTNAME', 'Jane');
+        expect(variables.run('FIRSTNAME || " " || LASTNAME')).toEqual('Jane Doe');
     });
-    (0, _vitest.it)('should ignore non array values', function () {
-      variables.set('FIRSTNAME', 'John');
-      (0, _vitest.expect)(variables.get('FIRSTNAME', [0])).toEqual('John');
+    it('should throw an exception when calculated incorrect VTL', () => {
+        expect(() => variables.run('Hello world')).toThrowError();
     });
-    (0, _vitest.it)('should handle iteration in calculation', function () {
-      variables.set('FIRSTNAME', ['John', 'Jane']);
-      variables.set('LASTNAME', ['Doe', 'Dae']);
-      variables.setCalculated('FULLNAME', 'FIRSTNAME || " " || LASTNAME', {
-        dependencies: ['FIRSTNAME', 'LASTNAME'],
-        shapeFrom: 'FIRSTNAME'
-      });
-      (0, _vitest.expect)(variables.get('FULLNAME', [0])).toEqual('John Doe');
-      (0, _vitest.expect)(variables.get('FULLNAME', [1])).toEqual('Jane Dae');
-      (0, _vitest.expect)(variables.interpretCount).toBe(2);
-      (0, _vitest.expect)(variables.get('FULLNAME', [0])).toEqual('John Doe');
-      (0, _vitest.expect)(variables.get('FULLNAME', [1])).toEqual('Jane Dae');
-      (0, _vitest.expect)(variables.interpretCount).toBe(2);
-      (0, _vitest.expect)(variables.get('FULLNAME', [0])).toEqual('John Doe');
-      variables.set('FIRSTNAME', ['John', 'Marc']);
-      (0, _vitest.expect)(variables.get('FULLNAME', [0])).toEqual('John Doe');
-      (0, _vitest.expect)(variables.get('FULLNAME', [1])).toEqual('Marc Dae');
-      // Only the second iteration should be calculated
-      (0, _vitest.expect)(variables.interpretCount).toBe(3);
+    describe('event listener', () => {
+        it('should trigger onChange', () => {
+            variables.set('FIRSTNAME', 'John');
+            const spy = vi.fn();
+            variables.on('change', (e) => spy(e.detail.name, e.detail.value));
+            variables.set('FIRSTNAME', 'Jane');
+            expect(spy).toHaveBeenCalledWith('FIRSTNAME', 'Jane');
+        });
+        it('should trigger onChange on array', () => {
+            variables.set('AGE', [18, 23, 24]);
+            const spy = vi.fn();
+            variables.on('change', (e) => spy(e.detail.name, e.detail.value));
+            variables.set('AGE', [18, 23]);
+            expect(spy).toHaveBeenCalledWith('AGE', [18, 23]);
+            variables.set('AGE', [18, 25]);
+            expect(spy).toHaveBeenCalledWith('AGE', [18, 25]);
+        });
+        it('should not trigger onChange when value does not change', () => {
+            variables.set('FIRSTNAME', 'John');
+            variables.set('AGE', [18, 20]);
+            const spy = vi.fn();
+            variables.on('change', (e) => spy(e.detail.name, e.detail.value));
+            variables.set('FIRSTNAME', 'John');
+            variables.set('AGE', [18, 20]);
+            expect(spy).not.toHaveBeenCalled();
+        });
     });
-    (0, _vitest.it)('should handle aggregation expression', function () {
-      variables.set('FIRSTNAME', ['John', 'Jane']);
-      (0, _vitest.expect)(variables.run('count(FIRSTNAME)')).toEqual(2);
-      variables.set('FIRSTNAME', ['John', 'Jane', 'Marc']);
-      (0, _vitest.expect)(variables.run('count(FIRSTNAME)')).toEqual(3);
+    describe('with iteration', () => {
+        it('should handle arrays', () => {
+            variables.set('FIRSTNAME', ['John', 'Jane']);
+            expect(variables.get('FIRSTNAME')).toEqual(['John', 'Jane']);
+            expect(variables.get('FIRSTNAME', [0])).toEqual('John');
+            expect(variables.get('FIRSTNAME', [1])).toEqual('Jane');
+        });
+        it('should handle setting at a specific index', () => {
+            variables.set('FIRSTNAME', ['John', 'Jane']);
+            variables.set('LASTNAME', null);
+            variables.set('FIRSTNAME', 'Marc', { iteration: [1] });
+            expect(variables.get('FIRSTNAME')).toEqual(['John', 'Marc']);
+            variables.set('LASTNAME', 'Doe', { iteration: [1] });
+            expect(variables.get('LASTNAME')).toEqual([null, 'Doe']);
+        });
+        it('should ignore non array values', () => {
+            variables.set('FIRSTNAME', 'John');
+            expect(variables.get('FIRSTNAME', [0])).toEqual('John');
+        });
+        it('should handle iteration in calculation', () => {
+            variables.set('FIRSTNAME', ['John', 'Jane']);
+            variables.set('LASTNAME', ['Doe', 'Dae']);
+            variables.setCalculated('FULLNAME', 'FIRSTNAME || " " || LASTNAME', {
+                dependencies: ['FIRSTNAME', 'LASTNAME'],
+                shapeFrom: 'FIRSTNAME',
+            });
+            expect(variables.get('FULLNAME', [0])).toEqual('John Doe');
+            expect(variables.get('FULLNAME', [1])).toEqual('Jane Dae');
+            expect(variables.interpretCount).toBe(2);
+            expect(variables.get('FULLNAME', [0])).toEqual('John Doe');
+            expect(variables.get('FULLNAME', [1])).toEqual('Jane Dae');
+            expect(variables.interpretCount).toBe(2);
+            expect(variables.get('FULLNAME', [0])).toEqual('John Doe');
+            variables.set('FIRSTNAME', ['John', 'Marc']);
+            expect(variables.get('FULLNAME', [0])).toEqual('John Doe');
+            expect(variables.get('FULLNAME', [1])).toEqual('Marc Dae');
+            // Only the second iteration should be calculated
+            expect(variables.interpretCount).toBe(3);
+        });
+        it('should handle aggregation expression', () => {
+            variables.set('FIRSTNAME', ['John', 'Jane']);
+            expect(variables.run('count(FIRSTNAME)')).toEqual(2);
+            variables.set('FIRSTNAME', ['John', 'Jane', 'Marc']);
+            expect(variables.run('count(FIRSTNAME)')).toEqual(3);
+        });
+        it('should handle non array values', () => {
+            variables.set('FIRSTNAME', ['John', 'Jane']);
+            variables.set('LASTNAME', 'Doe');
+            expect(variables.run('FIRSTNAME || " " || LASTNAME', { iteration: [0] })).toEqual('John Doe');
+            expect(variables.run('FIRSTNAME || " " || LASTNAME', { iteration: [1] })).toEqual('Jane Doe');
+        });
+        it('should handle global iteration variable', () => {
+            variables.set('FIRSTNAME', ['John', 'Jane']);
+            variables.setCalculated('FULLNAME', 'FIRSTNAME || " " || cast(GLOBAL_ITERATION_INDEX, string)', { shapeFrom: 'FIRSTNAME' });
+            expect(variables.get('FULLNAME', [0])).toEqual('John 1');
+            expect(variables.get('FULLNAME', [1])).toEqual('Jane 2');
+        });
+        it('should handle shapeFrom correctly', () => {
+            variables.set('FIRSTNAME', ['John', 'Jane']);
+            variables.setCalculated('FULLNAME', 'FIRSTNAME || " " || cast(GLOBAL_ITERATION_INDEX, string)', { shapeFrom: 'FIRSTNAME' });
+            expect(variables.get('FULLNAME')).toEqual(['John 1', 'Jane 2']);
+        });
+        it('should handle aggregate functions', () => {
+            variables.set('AGE', [1, 2, 3]);
+            variables.setCalculated('MAXAGE', 'max(AGE)');
+            variables.setCalculated('AGE_AND_MAX', 'AGE + MAXAGE', {
+                shapeFrom: 'AGE',
+            });
+            expect(variables.get('AGE_AND_MAX', [0])).toEqual(4);
+            variables.set('AGE', 12, { iteration: [1] });
+            expect(variables.get('AGE', [1])).toEqual(12);
+            expect(variables.get('AGE_AND_MAX', [0])).toEqual(13);
+        });
+        it('should handle primitive value', () => {
+            variables.run('"hello"', { iteration: [0] });
+            variables.run('"hello"', { iteration: [1] });
+            expect(variables.run('"hello"')).toEqual('hello');
+            expect(variables.interpretCount).toBe(3);
+        });
+        it('should handle deep refresh', () => {
+            variables.set('LIENS', [
+                ['17', null],
+                [null, '17'],
+            ]);
+            variables.setCalculated('IS_12', 'if ("12" in LIENS) then 1 else 0', {
+                dependencies: ['LIENS'],
+                shapeFrom: 'LIENS',
+            });
+            expect(variables.get('IS_12', [0])).toBe(0);
+            variables.set('LIENS', '12', { iteration: [0, 0] });
+            expect(variables.get('IS_12', [0])).toBe(1);
+        });
     });
-    (0, _vitest.it)('should handle non array values', function () {
-      variables.set('FIRSTNAME', ['John', 'Jane']);
-      variables.set('LASTNAME', 'Doe');
-      (0, _vitest.expect)(variables.run('FIRSTNAME || " " || LASTNAME', {
-        iteration: [0]
-      })).toEqual('John Doe');
-      (0, _vitest.expect)(variables.run('FIRSTNAME || " " || LASTNAME', {
-        iteration: [1]
-      })).toEqual('Jane Doe');
+    describe('resizing', () => {
+        it('should resize variables', () => {
+            variables.set('PRENOM', ['John', 'Jane']);
+            variables.set('NOM', ['Doe']);
+            resizingBehaviour(variables, {
+                PRENOM: {
+                    size: 'count(PRENOM)',
+                    variables: ['NOM'],
+                },
+            });
+            variables.set('PRENOM', ['John', 'Jane', 'Marc']);
+            expect(variables.get('PRENOM').length).toEqual(3);
+            expect(variables.get('NOM').length).toEqual(3);
+        });
+        it('should resize pairwise with the array syntax', () => {
+            variables.set('PRENOM', []);
+            variables.set('LINKS', [[]]);
+            resizingBehaviour(variables, {
+                PRENOM: {
+                    sizeForLinksVariables: ['count(PRENOM)', 'count(PRENOM)'],
+                    linksVariables: ['LINKS'],
+                },
+            });
+            variables.set('PRENOM', ['John', 'Jane', 'Marc']);
+            expect(variables.get('LINKS')).toEqual([
+                [null, null, null],
+                [null, null, null],
+                [null, null, null],
+            ]);
+        });
+        it('should resize pairwise with the object syntax', () => {
+            variables.set('PRENOM', []);
+            variables.set('LINKS', [[]]);
+            resizingBehaviour(variables, {
+                PRENOM: {
+                    sizeForLinksVariables: {
+                        xAxisSize: 'count(PRENOM)',
+                        yAxisSize: 'count(PRENOM)',
+                    },
+                    linksVariables: ['LINKS'],
+                },
+            });
+            variables.set('PRENOM', ['John', 'Jane', 'Marc']);
+            expect(variables.get('LINKS')).toEqual([
+                [null, null, null],
+                [null, null, null],
+                [null, null, null],
+            ]);
+        });
+        it('should handle both pairwise and normal resize', () => {
+            variables.set('PRENOM', []);
+            variables.set('NOM', []);
+            variables.set('LINKS', [[]]);
+            resizingBehaviour(variables, {
+                PRENOM: {
+                    sizeForLinksVariables: ['count(PRENOM)', 'count(PRENOM)'],
+                    linksVariables: ['LINKS'],
+                    size: 'count(PRENOM)',
+                    variables: ['NOM'],
+                },
+            });
+            variables.set('PRENOM', ['John', 'Jane', 'Marc']);
+            expect(variables.get('LINKS')).toEqual([
+                [null, null, null],
+                [null, null, null],
+                [null, null, null],
+            ]);
+            expect(variables.get('NOM')).toEqual([null, null, null]);
+        });
     });
-    (0, _vitest.it)('should handle global iteration variable', function () {
-      variables.set('FIRSTNAME', ['John', 'Jane']);
-      variables.setCalculated('FULLNAME', 'FIRSTNAME || " " || cast(GLOBAL_ITERATION_INDEX, string)', {
-        shapeFrom: 'FIRSTNAME'
-      });
-      (0, _vitest.expect)(variables.get('FULLNAME', [0])).toEqual('John 1');
-      (0, _vitest.expect)(variables.get('FULLNAME', [1])).toEqual('Jane 2');
+    describe('cleaning', () => {
+        it('should clean variables', () => {
+            variables.set('PRENOM', 'John');
+            variables.set('NOM', 'Doe');
+            variables.set('READY', true);
+            cleaningBehaviour(variables, {
+                READY: {
+                    PRENOM: 'READY',
+                },
+            });
+            expect(variables.get('PRENOM')).toEqual('John');
+            variables.set('READY', false);
+            expect(variables.get('PRENOM')).toEqual(null);
+        });
+        it('should clean variables with initial values', () => {
+            variables.set('PRENOM', 'John');
+            variables.set('READY', true);
+            cleaningBehaviour(variables, {
+                READY: {
+                    PRENOM: 'READY',
+                },
+            }, {
+                PRENOM: 'Jane',
+            });
+            variables.set('READY', false);
+            expect(variables.get('PRENOM')).toEqual('Jane');
+        });
+        it('should clean variables at a specific iteration', () => {
+            variables.set('PRENOM', ['John', 'Jane', 'Marc']);
+            variables.set('READY', [true, true, true]);
+            cleaningBehaviour(variables, {
+                READY: {
+                    PRENOM: 'READY',
+                },
+            }, { PRENOM: [null] });
+            variables.set('READY', false, { iteration: [1] });
+            expect(variables.get('PRENOM')).toEqual(['John', null, 'Marc']);
+        });
+        it('should clean variables with initial value at specific iteration', () => {
+            variables.set('PRENOM', ['John', 'Jane', 'Marc']);
+            variables.set('READY', [true, true, true]);
+            cleaningBehaviour(variables, {
+                READY: {
+                    PRENOM: 'READY',
+                },
+            }, { PRENOM: [null] });
+            variables.set('READY', false, { iteration: [1] });
+            expect(variables.get('PRENOM')).toEqual(['John', null, 'Marc']);
+        });
+        it('should clean root variables even when in an iteration', () => {
+            variables.set('PRENOM', 'John');
+            variables.set('READY', [true, true, true]);
+            cleaningBehaviour(variables, {
+                READY: {
+                    PRENOM: 'READY',
+                },
+            }, { PRENOM: null });
+            variables.set('READY', false, { iteration: [1] });
+            expect(variables.get('PRENOM')).toEqual(null);
+        });
     });
-    (0, _vitest.it)('should handle shapeFrom correctly', function () {
-      variables.set('FIRSTNAME', ['John', 'Jane']);
-      variables.setCalculated('FULLNAME', 'FIRSTNAME || " " || cast(GLOBAL_ITERATION_INDEX, string)', {
-        shapeFrom: 'FIRSTNAME'
-      });
-      (0, _vitest.expect)(variables.get('FULLNAME')).toEqual(['John 1', 'Jane 2']);
+    describe('missing', () => {
+        beforeEach(() => {
+            missingBehaviour(variables, {
+                PRENOM: ['PRENOM_MISSING'],
+                PRENOM_MISSING: ['PRENOM'],
+            });
+        });
+        it('should handle missing', () => {
+            variables.set('PRENOM', 'John');
+            expect(variables.get('PRENOM')).toEqual('John');
+            expect(variables.get('PRENOM_MISSING')).toEqual(null);
+            variables.set('PRENOM_MISSING', 'DK');
+            expect(variables.get('PRENOM')).toEqual(null);
+            expect(variables.get('PRENOM_MISSING')).toEqual('DK');
+        });
+        it('should handle missing for iteration', () => {
+            variables.set('PRENOM', ['John', 'Jane', 'Marc']);
+            expect(variables.get('PRENOM_MISSING')).toEqual(null);
+            variables.set('PRENOM_MISSING', 'DK', { iteration: [1] });
+            expect(variables.get('PRENOM')).toEqual(['John', null, 'Marc']);
+            expect(variables.get('PRENOM_MISSING', [1])).toEqual('DK');
+        });
     });
-    (0, _vitest.it)('should handle aggregate functions', function () {
-      variables.set('AGE', [1, 2, 3]);
-      variables.setCalculated('MAXAGE', 'max(AGE)');
-      variables.setCalculated('AGE_AND_MAX', 'AGE + MAXAGE', {
-        shapeFrom: 'AGE'
-      });
-      (0, _vitest.expect)(variables.get('AGE_AND_MAX', [0])).toEqual(4);
-      variables.set('AGE', 12, {
-        iteration: [1]
-      });
-      (0, _vitest.expect)(variables.get('AGE', [1])).toEqual(12);
-      (0, _vitest.expect)(variables.get('AGE_AND_MAX', [0])).toEqual(13);
-    });
-    (0, _vitest.it)('should handle primitive value', function () {
-      variables.run('"hello"', {
-        iteration: [0]
-      });
-      variables.run('"hello"', {
-        iteration: [1]
-      });
-      (0, _vitest.expect)(variables.run('"hello"')).toEqual('hello');
-      (0, _vitest.expect)(variables.interpretCount).toBe(3);
-    });
-    (0, _vitest.it)('should handle deep refresh', function () {
-      variables.set('LIENS', [['17', null], [null, '17']]);
-      variables.setCalculated('IS_12', 'if ("12" in LIENS) then 1 else 0', {
-        dependencies: ['LIENS'],
-        shapeFrom: 'LIENS'
-      });
-      (0, _vitest.expect)(variables.get('IS_12', [0])).toBe(0);
-      variables.set('LIENS', '12', {
-        iteration: [0, 0]
-      });
-      (0, _vitest.expect)(variables.get('IS_12', [0])).toBe(1);
-    });
-  });
-  (0, _vitest.describe)('resizing', function () {
-    (0, _vitest.it)('should resize variables', function () {
-      variables.set('PRENOM', ['John', 'Jane']);
-      variables.set('NOM', ['Doe']);
-      (0, _resizingBehaviour.resizingBehaviour)(variables, {
-        PRENOM: {
-          size: 'count(PRENOM)',
-          variables: ['NOM']
-        }
-      });
-      variables.set('PRENOM', ['John', 'Jane', 'Marc']);
-      (0, _vitest.expect)(variables.get('PRENOM').length).toEqual(3);
-      (0, _vitest.expect)(variables.get('NOM').length).toEqual(3);
-    });
-    (0, _vitest.it)('should resize pairwise with the array syntax', function () {
-      variables.set('PRENOM', []);
-      variables.set('LINKS', [[]]);
-      (0, _resizingBehaviour.resizingBehaviour)(variables, {
-        PRENOM: {
-          sizeForLinksVariables: ['count(PRENOM)', 'count(PRENOM)'],
-          linksVariables: ['LINKS']
-        }
-      });
-      variables.set('PRENOM', ['John', 'Jane', 'Marc']);
-      (0, _vitest.expect)(variables.get('LINKS')).toEqual([[null, null, null], [null, null, null], [null, null, null]]);
-    });
-    (0, _vitest.it)('should resize pairwise with the object syntax', function () {
-      variables.set('PRENOM', []);
-      variables.set('LINKS', [[]]);
-      (0, _resizingBehaviour.resizingBehaviour)(variables, {
-        PRENOM: {
-          sizeForLinksVariables: {
-            xAxisSize: 'count(PRENOM)',
-            yAxisSize: 'count(PRENOM)'
-          },
-          linksVariables: ['LINKS']
-        }
-      });
-      variables.set('PRENOM', ['John', 'Jane', 'Marc']);
-      (0, _vitest.expect)(variables.get('LINKS')).toEqual([[null, null, null], [null, null, null], [null, null, null]]);
-    });
-    (0, _vitest.it)('should handle both pairwise and normal resize', function () {
-      variables.set('PRENOM', []);
-      variables.set('NOM', []);
-      variables.set('LINKS', [[]]);
-      (0, _resizingBehaviour.resizingBehaviour)(variables, {
-        PRENOM: {
-          sizeForLinksVariables: ['count(PRENOM)', 'count(PRENOM)'],
-          linksVariables: ['LINKS'],
-          size: 'count(PRENOM)',
-          variables: ['NOM']
-        }
-      });
-      variables.set('PRENOM', ['John', 'Jane', 'Marc']);
-      (0, _vitest.expect)(variables.get('LINKS')).toEqual([[null, null, null], [null, null, null], [null, null, null]]);
-      (0, _vitest.expect)(variables.get('NOM')).toEqual([null, null, null]);
-    });
-  });
-  (0, _vitest.describe)('cleaning', function () {
-    (0, _vitest.it)('should clean variables', function () {
-      variables.set('PRENOM', 'John');
-      variables.set('NOM', 'Doe');
-      variables.set('READY', true);
-      (0, _cleaningBehaviour.cleaningBehaviour)(variables, {
-        READY: {
-          PRENOM: 'READY'
-        }
-      });
-      (0, _vitest.expect)(variables.get('PRENOM')).toEqual('John');
-      variables.set('READY', false);
-      (0, _vitest.expect)(variables.get('PRENOM')).toEqual(null);
-    });
-    (0, _vitest.it)('should clean variables with initial values', function () {
-      variables.set('PRENOM', 'John');
-      variables.set('READY', true);
-      (0, _cleaningBehaviour.cleaningBehaviour)(variables, {
-        READY: {
-          PRENOM: 'READY'
-        }
-      }, {
-        PRENOM: 'Jane'
-      });
-      variables.set('READY', false);
-      (0, _vitest.expect)(variables.get('PRENOM')).toEqual('Jane');
-    });
-    (0, _vitest.it)('should clean variables at a specific iteration', function () {
-      variables.set('PRENOM', ['John', 'Jane', 'Marc']);
-      variables.set('READY', [true, true, true]);
-      (0, _cleaningBehaviour.cleaningBehaviour)(variables, {
-        READY: {
-          PRENOM: 'READY'
-        }
-      }, {
-        PRENOM: [null]
-      });
-      variables.set('READY', false, {
-        iteration: [1]
-      });
-      (0, _vitest.expect)(variables.get('PRENOM')).toEqual(['John', null, 'Marc']);
-    });
-    (0, _vitest.it)('should clean variables with initial value at specific iteration', function () {
-      variables.set('PRENOM', ['John', 'Jane', 'Marc']);
-      variables.set('READY', [true, true, true]);
-      (0, _cleaningBehaviour.cleaningBehaviour)(variables, {
-        READY: {
-          PRENOM: 'READY'
-        }
-      }, {
-        PRENOM: [null]
-      });
-      variables.set('READY', false, {
-        iteration: [1]
-      });
-      (0, _vitest.expect)(variables.get('PRENOM')).toEqual(['John', null, 'Marc']);
-    });
-    (0, _vitest.it)('should clean root variables even when in an iteration', function () {
-      variables.set('PRENOM', 'John');
-      variables.set('READY', [true, true, true]);
-      (0, _cleaningBehaviour.cleaningBehaviour)(variables, {
-        READY: {
-          PRENOM: 'READY'
-        }
-      }, {
-        PRENOM: null
-      });
-      variables.set('READY', false, {
-        iteration: [1]
-      });
-      (0, _vitest.expect)(variables.get('PRENOM')).toEqual(null);
-    });
-  });
-  (0, _vitest.describe)('missing', function () {
-    (0, _vitest.beforeEach)(function () {
-      (0, _missingBehaviour.missingBehaviour)(variables, {
-        PRENOM: ['PRENOM_MISSING'],
-        PRENOM_MISSING: ['PRENOM']
-      });
-    });
-    (0, _vitest.it)('should handle missing', function () {
-      variables.set('PRENOM', 'John');
-      (0, _vitest.expect)(variables.get('PRENOM')).toEqual('John');
-      (0, _vitest.expect)(variables.get('PRENOM_MISSING')).toEqual(null);
-      variables.set('PRENOM_MISSING', 'DK');
-      (0, _vitest.expect)(variables.get('PRENOM')).toEqual(null);
-      (0, _vitest.expect)(variables.get('PRENOM_MISSING')).toEqual('DK');
-    });
-    (0, _vitest.it)('should handle missing for iteration', function () {
-      variables.set('PRENOM', ['John', 'Jane', 'Marc']);
-      (0, _vitest.expect)(variables.get('PRENOM_MISSING')).toEqual(null);
-      variables.set('PRENOM_MISSING', 'DK', {
-        iteration: [1]
-      });
-      (0, _vitest.expect)(variables.get('PRENOM')).toEqual(['John', null, 'Marc']);
-      (0, _vitest.expect)(variables.get('PRENOM_MISSING', [1])).toEqual('DK');
-    });
-  });
-});
+});
+//# sourceMappingURL=lunatic-variables-store.spec.js.map