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

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

@@ -1,418 +1,338 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.LunaticVariablesStore = void 0;
-var _vtl = require("../../../utils/vtl");
-var _env = require("../../../utils/env");
-var _variables = require("../../../utils/variables");
-var _resizingBehaviour = require("./behaviours/resizing-behaviour");
-var _cleaningBehaviour = require("./behaviours/cleaning-behaviour");
-var _missingBehaviour = require("./behaviours/missing-behaviour");
-var _array = require("../../../utils/array");
-var _number = require("../../../utils/number");
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function (_e) { function e(_x) { return _e.apply(this, arguments); } e.toString = function () { return _e.toString(); }; return e; }(function (e) { throw e; }), f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function (_e2) { function e(_x2) { return _e2.apply(this, arguments); } e.toString = function () { return _e2.toString(); }; return e; }(function (e) { didErr = true; err = e; }), f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { interpretVTL, parseVTLVariables } from '../../../utils/vtl';
+import { isTestEnv } from '../../../utils/env';
+import { getInitialVariableValue } from '../../../utils/variables';
+import { resizingBehaviour } from './behaviours/resizing-behaviour';
+import { cleaningBehaviour } from './behaviours/cleaning-behaviour';
+import { missingBehaviour } from './behaviours/missing-behaviour';
+import { setAtIndex, subArrays, times } from '../../../utils/array';
+import { isNumber } from '../../../utils/number';
 // Interpret counter, used for testing purpose
-var interpretCount = 0;
+let interpretCount = 0;
 // Special variable that will take the current iteration value
-var iterationVariableName = 'GLOBAL_ITERATION_INDEX';
-var LunaticVariablesStore = exports.LunaticVariablesStore = /*#__PURE__*/function () {
-  function LunaticVariablesStore() {
-    _classCallCheck(this, LunaticVariablesStore);
-    this.dictionary = new Map();
-    this.eventTarget = new EventTarget();
-    interpretCount = 0;
-  }
-  _createClass(LunaticVariablesStore, [{
-    key: "get",
-    value:
+const iterationVariableName = 'GLOBAL_ITERATION_INDEX';
+export class LunaticVariablesStore {
+    dictionary = new Map();
+    eventTarget = new EventTarget();
+    constructor() {
+        interpretCount = 0;
+    }
+    static makeFromSource(source, data) {
+        const store = new LunaticVariablesStore();
+        if (!source.variables) {
+            return store;
+        }
+        const initialValues = Object.fromEntries(source.variables.map((variable) => [
+            variable.name,
+            getInitialVariableValue(variable, data),
+        ]));
+        const getIterationDepth = (name) => {
+            if (name === 'xAxis')
+                return 0;
+            if (name === 'yAxis')
+                return 1;
+            return undefined;
+        };
+        store.set('1', 1); // Fake variable to use on the shapeFrom, we will use "variableDimension" in the future
+        for (const variable of source.variables) {
+            switch (variable.variableType) {
+                case 'CALCULATED':
+                    store.setCalculated(variable.name, variable.expression.value, {
+                        dependencies: variable.bindingDependencies,
+                        iterationDepth: getIterationDepth(variable.name),
+                        shapeFrom: variable.shapeFrom ?? '1',
+                    });
+                    break;
+                case 'COLLECTED':
+                case 'EXTERNAL':
+                    store.set(variable.name, initialValues[variable.name ?? null]);
+                    break;
+            }
+        }
+        cleaningBehaviour(store, source.cleaning, initialValues);
+        resizingBehaviour(store, source.resizing);
+        missingBehaviour(store, source.missingBlock);
+        return store;
+    }
+    /**
+     * Create a new store from an object (useful for testing)
+     */
+    static makeFromObject(values = {}) {
+        const store = new LunaticVariablesStore();
+        for (const name of Object.keys(values)) {
+            store.set(name, values[name]);
+        }
+        return store;
+    }
     /**
      * Retrieve variable value
      */
-    function get(name, iteration) {
-      if (!this.dictionary.has(name)) {
-        return null;
-      }
-      return this.dictionary.get(name).getValue(iteration);
+    get(name, iteration) {
+        if (!this.dictionary.has(name)) {
+            return null;
+        }
+        return this.dictionary.get(name).getValue(iteration);
     }
-
     /**
      * Set variable value
      */
-  }, {
-    key: "set",
-    value: function set(name, value) {
-      var args = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-      if (!this.dictionary.has(name)) {
-        this.dictionary.set(name, new LunaticVariable({
-          name: name
-        }));
-      }
-      var variable = this.dictionary.get(name);
-      if (variable.setValue(value, args.iteration)) {
-        this.eventTarget.dispatchEvent(new CustomEvent('change', {
-          detail: _objectSpread(_objectSpread({}, args), {}, {
-            name: name,
-            value: value
-          })
-        }));
-      }
-      return variable;
+    set(name, value, args = {}) {
+        if (!this.dictionary.has(name)) {
+            this.dictionary.set(name, new LunaticVariable({
+                name,
+            }));
+        }
+        const variable = this.dictionary.get(name);
+        if (variable.setValue(value, args.iteration)) {
+            this.eventTarget.dispatchEvent(new CustomEvent('change', {
+                detail: {
+                    ...args,
+                    name: name,
+                    value: value,
+                },
+            }));
+        }
+        return variable;
     }
-
     /**
      * Register calculated variable
      */
-  }, {
-    key: "setCalculated",
-    value: function setCalculated(name, expression) {
-      var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
-        dependencies = _ref.dependencies,
-        iterationDepth = _ref.iterationDepth,
-        shapeFrom = _ref.shapeFrom;
-      if (this.dictionary.has(name)) {
-        return this.dictionary.get(name);
-      }
-      var variable = new LunaticVariable({
-        expression: expression,
-        dictionary: this.dictionary,
-        shapeFrom: shapeFrom,
-        dependencies: dependencies,
-        iterationDepth: iterationDepth,
-        name: name
-      });
-      this.dictionary.set(name, variable);
-      return variable;
+    setCalculated(name, expression, { dependencies, iterationDepth, shapeFrom, } = {}) {
+        if (this.dictionary.has(name)) {
+            return this.dictionary.get(name);
+        }
+        const variable = new LunaticVariable({
+            expression: expression,
+            dictionary: this.dictionary,
+            shapeFrom,
+            dependencies,
+            iterationDepth,
+            name,
+        });
+        this.dictionary.set(name, variable);
+        return variable;
     }
-
     /**
      * Run a VTL expression
      */
-  }, {
-    key: "run",
-    value: function run(expression) {
-      var args = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      return this.setCalculated(expression, expression, {
-        dependencies: args.deps
-      }).getValue(args.iteration);
+    run(expression, args = {}) {
+        return this.setCalculated(expression, expression, {
+            dependencies: args.deps,
+        }).getValue(args.iteration);
     }
-
     /**
      * Bind event listeners
      */
-  }, {
-    key: "on",
-    value: function on(eventName, cb) {
-      this.eventTarget.addEventListener(eventName, cb);
+    on(eventName, cb) {
+        this.eventTarget.addEventListener(eventName, cb);
     }
-
     /**
      * Detach a listener
      */
-  }, {
-    key: "off",
-    value: function off(eventName, cb) {
-      this.eventTarget.removeEventListener(eventName, cb);
+    off(eventName, cb) {
+        this.eventTarget.removeEventListener(eventName, cb);
     }
-
     // Retrieve the number of interpret() run (used in testing only)
-  }, {
-    key: "interpretCount",
-    get: function get() {
-      return interpretCount;
+    get interpretCount() {
+        return interpretCount;
     }
-  }], [{
-    key: "makeFromSource",
-    value: function makeFromSource(source, data) {
-      var _variable$name;
-      var store = new LunaticVariablesStore();
-      if (!source.variables) {
-        return store;
-      }
-      var initialValues = Object.fromEntries(source.variables.map(function (variable) {
-        return [variable.name, (0, _variables.getInitialVariableValue)(variable, data)];
-      }));
-      var getIterationDepth = function getIterationDepth(name) {
-        if (name === 'xAxis') return 0;
-        if (name === 'yAxis') return 1;
-        return undefined;
-      };
-      var _iterator = _createForOfIteratorHelper(source.variables),
-        _step;
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var variable = _step.value;
-          switch (variable.variableType) {
-            case 'CALCULATED':
-              store.setCalculated(variable.name, variable.expression.value, {
-                dependencies: variable.bindingDependencies,
-                iterationDepth: getIterationDepth(variable.name),
-                shapeFrom: variable.shapeFrom
-              });
-              break;
-            case 'COLLECTED':
-            case 'EXTERNAL':
-              store.set(variable.name, initialValues[(_variable$name = variable.name) !== null && _variable$name !== void 0 ? _variable$name : null]);
-              break;
-          }
-        }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
-      }
-      (0, _cleaningBehaviour.cleaningBehaviour)(store, source.cleaning, initialValues);
-      (0, _resizingBehaviour.resizingBehaviour)(store, source.resizing);
-      (0, _missingBehaviour.missingBehaviour)(store, source.missingBlock);
-      return store;
-    }
-
-    /**
-     * Create a new store from an object (useful for testing)
-     */
-  }, {
-    key: "makeFromObject",
-    value: function makeFromObject() {
-      var values = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-      var store = new LunaticVariablesStore();
-      for (var _i = 0, _Object$keys = Object.keys(values); _i < _Object$keys.length; _i++) {
-        var name = _Object$keys[_i];
-        store.set(name, values[name]);
-      }
-      return store;
+    // Displays a table of the most calculated variable (useful for debug)
+    debug() {
+        console.table(Array.from(this.dictionary.values())
+            .sort((a, b) => b.calculatedCount - a.calculatedCount)
+            .slice(0, 25)
+            .map((v) => ({
+            name: v.name,
+            calculations: v.calculatedCount,
+            expression: v.expression,
+        })));
+        console.log('Total calculations : ' +
+            Array.from(this.dictionary.values()).reduce((acc, v) => acc + v.calculatedCount, 0));
+        Array.from(this.dictionary.values()).map((v) => (v.calculatedCount = 0));
     }
-  }]);
-  return LunaticVariablesStore;
-}();
-var LunaticVariable = /*#__PURE__*/function () {
-  function LunaticVariable() {
-    var _args$name;
-    var args = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    _classCallCheck(this, LunaticVariable);
+}
+class LunaticVariable {
     // Last time the value was updated (changed)
-    this.updatedAt = new Map();
+    updatedAt = new Map();
     // Last time "calculation" was run (for calculated variable)
-    this.calculatedAt = new Map();
+    calculatedAt = new Map();
     // Internal value for the variable
-    this.value = void 0;
+    value;
     // List of dependencies, ex: ['FIRSTNAME', 'LASTNAME']
-    this.dependencies = void 0;
+    dependencies;
     // Expression for calculated variable
-    this.expression = void 0;
+    expression;
     // Dictionary holding all the available variables
-    this.dictionary = void 0;
+    dictionary;
     // Specific iteration depth to get value from dependencies (used for yAxis for instance)
-    this.iterationDepth = void 0;
+    iterationDepth;
     // For calculated variable, shape is copied from another variable
-    this.shapeFrom = void 0;
+    shapeFrom;
     // Keep a record of variable name (optional, used for debug)
-    this.name = void 0;
-    if (args.expression && !args.dictionary) {
-      throw new Error("A calculated variable needs a dictionary to retrieve his deps");
+    name;
+    // Count the number of calculation
+    calculatedCount = 0;
+    constructor(args = {}) {
+        if (args.expression && !args.dictionary) {
+            throw new Error(`A calculated variable needs a dictionary to retrieve his deps`);
+        }
+        this.expression = args.expression;
+        this.dictionary = args.dictionary;
+        this.dependencies = args.dependencies;
+        this.iterationDepth = args.iterationDepth;
+        this.shapeFrom = args.shapeFrom;
+        this.name = args.name ?? args.expression;
     }
-    this.expression = args.expression;
-    this.dictionary = args.dictionary;
-    this.dependencies = args.dependencies;
-    this.iterationDepth = args.iterationDepth;
-    this.shapeFrom = args.shapeFrom;
-    this.name = (_args$name = args.name) !== null && _args$name !== void 0 ? _args$name : args.expression;
-  }
-  _createClass(LunaticVariable, [{
-    key: "getValue",
-    value: function getValue(iteration) {
-      var _this$dictionary,
-        _this = this;
-      // The variable is not calculated
-      if (!this.expression) {
-        return this.getSavedValue(iteration);
-      }
-      var shapeFromValue = this.shapeFrom ? (_this$dictionary = this.dictionary) === null || _this$dictionary === void 0 || (_this$dictionary = _this$dictionary.get(this.shapeFrom)) === null || _this$dictionary === void 0 ? void 0 : _this$dictionary.getValue() : null;
-      // If we want the root value of a calculated array, loop using the shapeFrom value
-      if (!iteration && Array.isArray(shapeFromValue)) {
-        return shapeFromValue.map(function (_, k) {
-          return _this.getValue([k]);
-        });
-      }
-
-      // For calculated variable, ignore iteration if shapeFrom exists and is not an array
-      if (
-      // We have a calculated variable (not a simple expression)
-      this.name !== this.expression && !Array.isArray(shapeFromValue)) {
-        iteration = undefined;
-      }
-
-      // Calculate bindings first to refresh "updatedAt" on calculated dependencies
-      var bindings = this.getDependenciesValues(iteration);
-      // A variable without binding is a primitive (string, boolean...)
-      // it yields the same results for every iteration, so we can ignore iteration
-      if (Object.keys(bindings).length === 0) {
-        iteration = undefined;
-      }
-      if (this.shapeFrom && !this.isOutdated(iteration)) {
+    getValue(iteration) {
+        // The variable is not calculated
+        if (!this.expression) {
+            return this.getSavedValue(iteration);
+        }
+        const shapeFromValue = this.shapeFrom
+            ? this.dictionary?.get(this.shapeFrom)?.getValue()
+            : null;
+        // If we want the root value of a calculated array, loop using the shapeFrom value
+        if (!iteration && Array.isArray(shapeFromValue)) {
+            return shapeFromValue.map((_, k) => this.getValue([k]));
+        }
+        // For calculated variable, ignore iteration if shapeFrom exists and is not an array
+        if (
+        // We have a calculated variable (not a simple expression)
+        this.name !== this.expression &&
+            !Array.isArray(shapeFromValue)) {
+            iteration = undefined;
+        }
+        // Calculate bindings first to refresh "updatedAt" on calculated dependencies
+        const bindings = this.getDependenciesValues(iteration);
+        // A variable without binding is a primitive (string, boolean...)
+        // it yields the same results for every iteration, so we can ignore iteration
+        if (Object.keys(bindings).length === 0) {
+            iteration = undefined;
+        }
+        if (this.shapeFrom && !this.isOutdated(iteration)) {
+            return this.getSavedValue(iteration);
+        }
+        if (isTestEnv()) {
+            interpretCount++;
+        }
+        // Scale down iteration if its dimension > shapeFrom dimension
+        const shapeDimension = arrayDimension(shapeFromValue);
+        if (Array.isArray(iteration) &&
+            Array.isArray(shapeFromValue) &&
+            shapeDimension < iteration.length) {
+            iteration = iteration.slice(0, shapeDimension);
+        }
+        // Uncomment this if you want to track the number of calculation
+        // this.calculatedCount++;
+        // Remember the value
+        try {
+            this.setValue(interpretVTL(this.expression, bindings), iteration);
+        }
+        catch (e) {
+            throw new Error(`Cannot interpret expression "${this.expression}" with bindings ${JSON.stringify(bindings)}, error : ${e.toString()}`);
+        }
+        this.updateTimestamps(iteration, 'calculatedAt');
         return this.getSavedValue(iteration);
-      }
-      if ((0, _env.isTestEnv)()) {
-        interpretCount++;
-      }
-      // Remember the value
-      try {
-        this.setValue((0, _vtl.interpretVTL)(this.expression, bindings), iteration);
-      } catch (e) {
-        throw new Error("Cannot interpret expression \"".concat(this.expression, "\" with bindings ").concat(JSON.stringify(bindings), ", error : ").concat(e.toString()));
-      }
-      this.updateTimestamps(iteration, 'calculatedAt');
-      return this.getSavedValue(iteration);
     }
-
     /**
      * Set the value and returns true if the variable is touched
      */
-  }, {
-    key: "setValue",
-    value: function setValue(value, iteration) {
-      if (value === this.getSavedValue(iteration)) {
-        return false;
-      }
-      // Decompose arrays, to only update items that changed
-      if (Array.isArray(value) && !Array.isArray(iteration)) {
-        return this.setValueForArray(value);
-      }
-      // We want to save a value at a specific iteration, but the value is not an array yet
-      if (iteration !== undefined && !Array.isArray(this.value)) {
-        this.value = [];
-      }
-      this.value = !Array.isArray(iteration) ? value : (0, _array.setAtIndex)(this.value, iteration, value);
-      this.updateTimestamps(iteration, 'updatedAt');
-      return true;
+    setValue(value, iteration) {
+        if (value === this.getSavedValue(iteration)) {
+            return false;
+        }
+        // Decompose arrays, to only update items that changed
+        if (Array.isArray(value) && !Array.isArray(iteration)) {
+            return this.setValueForArray(value);
+        }
+        // We want to save a value at a specific iteration, but the value is not an array yet
+        if (iteration !== undefined && !Array.isArray(this.value)) {
+            this.value = [];
+        }
+        this.value = !Array.isArray(iteration)
+            ? value
+            : setAtIndex(this.value, iteration, value);
+        this.updateTimestamps(iteration, 'updatedAt');
+        return true;
     }
-  }, {
-    key: "updateTimestamps",
-    value: function updateTimestamps(iteration, key) {
-      // Update parent iteration level timestamp
-      var _iterator2 = _createForOfIteratorHelper((0, _array.subArrays)(iteration)),
-        _step2;
-      try {
-        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-          var subIteration = _step2.value;
-          this[key].set(subIteration.join('.'), performance.now());
+    updateTimestamps(iteration, key) {
+        // Update parent iteration level timestamp
+        for (const subIteration of subArrays(iteration)) {
+            this[key].set(subIteration.join('.'), performance.now());
         }
-      } catch (err) {
-        _iterator2.e(err);
-      } finally {
-        _iterator2.f();
-      }
-      this[key].set(undefined, performance.now());
+        this[key].set(undefined, performance.now());
     }
-  }, {
-    key: "setValueForArray",
-    value: function setValueForArray(value) {
-      var _this2 = this;
-      var savedValue = this.getSavedValue();
-      var oldSize = Array.isArray(savedValue) ? savedValue.length : -1;
-      var newSize = value.length;
-      // Update every item of the array and look if we changed one item
-      var oneValueChanged = (0, _array.times)(Math.max(oldSize, newSize), function (k) {
-        return _this2.setValue(value[k], [k]);
-      }).find(function (v) {
-        return v;
-      }) !== undefined;
-      // New array is smaller, shorten the array
-      if (oldSize > newSize && Array.isArray(this.value)) {
-        this.value = this.value.slice(0, newSize);
-      }
-      return oneValueChanged;
+    setValueForArray(value) {
+        const savedValue = this.getSavedValue();
+        const oldSize = Array.isArray(savedValue) ? savedValue.length : -1;
+        const newSize = value.length;
+        // Update every item of the array and look if we changed one item
+        const oneValueChanged = times(Math.max(oldSize, newSize), (k) => this.setValue(value[k], [k])).find((v) => v) !== undefined;
+        // New array is smaller, shorten the array
+        if (oldSize > newSize && Array.isArray(this.value)) {
+            this.value = this.value.slice(0, newSize);
+        }
+        return oneValueChanged;
     }
-  }, {
-    key: "getSavedValue",
-    value: function getSavedValue(iteration) {
-      if (!Array.isArray(iteration)) {
-        return this.value;
-      }
-      var current = this.value;
-      var _iterator3 = _createForOfIteratorHelper(iteration),
-        _step3;
-      try {
-        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-          var index = _step3.value;
-          if (!Array.isArray(current)) {
-            return current;
-          }
-          current = current[index];
+    getSavedValue(iteration) {
+        if (!Array.isArray(iteration)) {
+            return this.value;
+        }
+        let current = this.value;
+        for (const index of iteration) {
+            if (!Array.isArray(current)) {
+                return current;
+            }
+            current = current[index];
         }
-      } catch (err) {
-        _iterator3.e(err);
-      } finally {
-        _iterator3.f();
-      }
-      return current;
+        return current;
     }
-  }, {
-    key: "getDependencies",
-    value: function getDependencies() {
-      // Calculate dependencies from expression on the fly if necessary
-      if (this.dependencies === undefined) {
-        this.dependencies = (0, _vtl.parseVTLVariables)(this.expression);
-      }
-      return this.dependencies;
+    getDependencies() {
+        // Calculate dependencies from expression on the fly if necessary
+        if (this.dependencies === undefined) {
+            this.dependencies = parseVTLVariables(this.expression);
+        }
+        return this.dependencies;
     }
-  }, {
-    key: "getDependenciesValues",
-    value: function getDependenciesValues(iteration) {
-      var _this3 = this;
-      try {
-        return Object.fromEntries(this.getDependencies().map(function (dep) {
-          var _this3$dictionary, _this3$dictionary$get;
-          if (dep === iterationVariableName && iteration) {
-            return [dep, iteration[0] + 1];
-          }
-          var dependencyIteration = (0, _number.isNumber)(_this3.iterationDepth) && Array.isArray(iteration) ? [iteration[_this3.iterationDepth]] : iteration;
-
-          // The variable is not registered in the variable dictionary
-          // Happens when calculating unquoted VTL expression
-          if (!_this3.dictionary || !((_this3$dictionary = _this3.dictionary) !== null && _this3$dictionary !== void 0 && _this3$dictionary.has(dep))) {
-            throw new Error("Unknown variable \"".concat(dep, "\" in expression ").concat(_this3.expression));
-          }
-          return [dep, (_this3$dictionary$get = _this3.dictionary.get(dep)) === null || _this3$dictionary$get === void 0 ? void 0 : _this3$dictionary$get.getValue(dependencyIteration)];
-        }));
-      } catch (e) {
-        if (e instanceof RangeError) {
-          throw new Error("Cannot resolve dependencies for \"".concat(this.expression, "\" with dependencies ").concat(JSON.stringify(this.getDependencies()), " \n ").concat(e.toString()));
+    getDependenciesValues(iteration) {
+        try {
+            return Object.fromEntries(this.getDependencies().map((dep) => {
+                if (dep === iterationVariableName && iteration) {
+                    return [dep, iteration[0] + 1];
+                }
+                const dependencyIteration = isNumber(this.iterationDepth) && Array.isArray(iteration)
+                    ? [iteration[this.iterationDepth]]
+                    : iteration;
+                // The variable is not registered in the variable dictionary
+                // Happens when calculating unquoted VTL expression
+                if (!this.dictionary || !this.dictionary?.has(dep)) {
+                    throw new Error(`Unknown variable "${dep}" in expression ${this.expression}`);
+                }
+                return [dep, this.dictionary.get(dep)?.getValue(dependencyIteration)];
+            }));
         }
-        throw e;
-      }
+        catch (e) {
+            if (e instanceof RangeError) {
+                throw new Error(`Cannot resolve dependencies for "${this.expression}" with dependencies ${JSON.stringify(this.getDependencies())} \n ${e.toString()}`);
+            }
+            throw e;
+        }
+    }
+    isOutdated(iteration) {
+        const dependenciesUpdatedAt = Math.max(0, ...this.getDependencies().map((dep) => 
+        // Check when a value at the same iteration was calculated
+        this.dictionary?.get(dep)?.updatedAt.get(iteration?.join('.')) ??
+            // For aggregated value (max / min) look the global updatedAt time
+            this.dictionary?.get(dep)?.updatedAt.get(undefined) ??
+            // Otherwise this is a static value that never changes
+            0));
+        return (dependenciesUpdatedAt >
+            (this.calculatedAt.get(iteration?.join('.')) ?? -1));
     }
-  }, {
-    key: "isOutdated",
-    value: function isOutdated(iteration) {
-      var _this4 = this,
-        _this$calculatedAt$ge;
-      var dependenciesUpdatedAt = Math.max.apply(Math, [0].concat(_toConsumableArray(this.getDependencies().map(function (dep) {
-        var _ref2, _this4$dictionary$get, _this4$dictionary, _this4$dictionary2;
-        return (// Check when a value at the same iteration was calculated
-          (_ref2 = (_this4$dictionary$get = (_this4$dictionary = _this4.dictionary) === null || _this4$dictionary === void 0 || (_this4$dictionary = _this4$dictionary.get(dep)) === null || _this4$dictionary === void 0 ? void 0 : _this4$dictionary.updatedAt.get(iteration === null || iteration === void 0 ? void 0 : iteration.join('.'))) !== null && _this4$dictionary$get !== void 0 ? _this4$dictionary$get : // For aggregated value (max / min) look the global updatedAt time
-          (_this4$dictionary2 = _this4.dictionary) === null || _this4$dictionary2 === void 0 || (_this4$dictionary2 = _this4$dictionary2.get(dep)) === null || _this4$dictionary2 === void 0 ? void 0 : _this4$dictionary2.updatedAt.get(undefined)) !== null && _ref2 !== void 0 ? _ref2 :
-          // Otherwise this is a static value that never changes
-          0
-        );
-      }))));
-      return dependenciesUpdatedAt > ((_this$calculatedAt$ge = this.calculatedAt.get(iteration === null || iteration === void 0 ? void 0 : iteration.join('.'))) !== null && _this$calculatedAt$ge !== void 0 ? _this$calculatedAt$ge : -1);
+}
+function arrayDimension(arr) {
+    if (!Array.isArray(arr)) {
+        return 0;
     }
-  }]);
-  return LunaticVariable;
-}();
+    return 1 + arrayDimension(arr[0]);
+}
+//# sourceMappingURL=lunatic-variables-store.js.map