@inseefr/lunatic 2.6.2 → 2.6.3-rc.1

package/lib/use-lunatic/commons/index.js

@@ -9,12 +9,6 @@ Object.defineProperty(exports, "checkLoops", {
     return _checkLoops["default"];
   }
 });
-Object.defineProperty(exports, "createExecuteExpression", {
-  enumerable: true,
-  get: function get() {
-    return _executeExpression["default"];
-  }
-});
 Object.defineProperty(exports, "createMapPages", {
   enumerable: true,
   get: function get() {
@@ -45,12 +39,6 @@ Object.defineProperty(exports, "getComponentsFromState", {
     return _getComponentsFromState["default"];
   }
 });
-Object.defineProperty(exports, "getErrorsWithoutEmptyValue", {
-  enumerable: true,
-  get: function get() {
-    return _getErrorsWithoutEmptyValue["default"];
-  }
-});
 Object.defineProperty(exports, "getNewReachedPage", {
   enumerable: true,
   get: function get() {
@@ -75,12 +63,6 @@ Object.defineProperty(exports, "isNewReachedPage", {
     return _pageTag.isNewReachedPage;
   }
 });
-Object.defineProperty(exports, "isPaginatedLoop", {
-  enumerable: true,
-  get: function get() {
-    return _isPaginatedLoop["default"];
-  }
-});
 Object.defineProperty(exports, "useComponentsFromState", {
   enumerable: true,
   get: function get() {
@@ -90,13 +72,10 @@ Object.defineProperty(exports, "useComponentsFromState", {
 var _checkLoops = _interopRequireDefault(require("./check-loops"));
 var _createMapPages = _interopRequireDefault(require("./create-map-pages"));
 var _executeConditionFilter = _interopRequireDefault(require("./execute-condition-filter"));
-var _executeExpression = _interopRequireDefault(require("./execute-expression"));
 var _fillComponentExpressions = _interopRequireDefault(require("./fill-components/fill-component-expressions"));
 var _getCompatibleVtlExpression = _interopRequireDefault(require("./get-compatible-vtl-expression"));
 var _getComponentsFromState = _interopRequireDefault(require("./get-components-from-state"));
-var _getErrorsWithoutEmptyValue = _interopRequireDefault(require("./get-errors-without-empty-value"));
 var _isFirstLastPage = _interopRequireDefault(require("./is-First-last-page"));
-var _isPaginatedLoop = _interopRequireDefault(require("./is-paginated-loop"));
 var _pageTag = require("./page-tag");
 var _useComponentsFromState = _interopRequireDefault(require("./use-components-from-state"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

package/lib/use-lunatic/commons/variables/behaviours/cleaning-behaviour.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cleaningBehaviour = cleaningBehaviour;
+/**
+ * Cleaning behaviour for the store
+ * When a variable changes, other variables can be reset
+ */
+function cleaningBehaviour(store, cleaning) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  if (!cleaning) {
+    return;
+  }
+
+  // Create a map to improve performance
+  var cleaningMap = new Map(Object.entries(cleaning));
+  store.on('change', function (e) {
+    var cleaningInfo = cleaningMap.get(e.detail.name);
+
+    // The variable does not have cleaning
+    if (!cleaningInfo) {
+      return;
+    }
+    for (var variableName in cleaningInfo) {
+      var _initialValues$variab;
+      var skipCleaning = store.run(cleaningInfo[variableName], {
+        iteration: e.detail.iteration
+      });
+      if (skipCleaning) {
+        continue;
+      }
+      store.set(variableName, (_initialValues$variab = initialValues[variableName]) !== null && _initialValues$variab !== void 0 ? _initialValues$variab : null, {
+        iteration: e.detail.iteration
+      });
+    }
+  });
+}

package/lib/use-lunatic/commons/variables/behaviours/missing-behaviour.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.missingBehaviour = missingBehaviour;
+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(_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 e(_e2) { didErr = true; err = _e2; }, 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; }
+/**
+ * Add missing behaviour to the store
+ * Missing works as a simplified cleaning that reset a linked variable
+ */
+function missingBehaviour(store, missing) {
+  if (!missing) {
+    return;
+  }
+
+  // Create a map to improve performance
+  var missingMap = new Map(Object.entries(missing));
+  store.on('change', function (e) {
+    // Only clean if a value is set
+    if (e.detail.value === null || e.detail.value === undefined) {
+      return;
+    }
+    var linkedVariables = missingMap.get(e.detail.name);
+
+    // The variable does not have missing variable linked
+    if (!linkedVariables) {
+      return;
+    }
+    var _iterator = _createForOfIteratorHelper(linkedVariables),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var variableName = _step.value;
+        store.set(variableName, null, {
+          iteration: e.detail.iteration
+        });
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  });
+}

package/lib/use-lunatic/commons/variables/behaviours/resizing-behaviour.js

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resizingBehaviour = resizingBehaviour;
+var _number = require("../../../../utils/number");
+var _commons = require("../../../reducer/commons");
+var _vtl = require("../../../../utils/vtl");
+var _array = require("../../../../utils/array");
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return 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(_e2) { throw _e2; }, 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 e(_e3) { didErr = true; err = _e3; }, 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; }
+/**
+ * Resizing behaviour for the store
+ * When a variable changes, multiple other variables can change size (size of the array)
+ */
+function resizingBehaviour(store, resizing) {
+  if (!resizing) {
+    return;
+  }
+
+  // Create a map to improve performance
+  var resizingMap = new Map(Object.entries(resizing));
+  store.on('change', function (e) {
+    // The variable does not have resizing
+    var resizingInfo = resizingMap.get(e.detail.name);
+    if (!resizingInfo) {
+      return;
+    }
+
+    // Pairwise resizing
+    if ('sizeForLinksVariables' in resizingInfo) {
+      resizePairwise(store, resizingInfo, e.detail);
+      return;
+    }
+    if (!resizingInfo.size) {
+      throw new Error("Cannot resize ".concat(e.detail.name, " missing \"size\" property"));
+    }
+    var newSize = (0, _number.forceInt)(store.run(resizingInfo.size));
+    var _iterator = _createForOfIteratorHelper(resizingInfo.variables),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var variableName = _step.value;
+        var value = store.get(variableName);
+        if (!Array.isArray(value) || value.length !== newSize) {
+          store.set(variableName, (0, _commons.resizeArrayVariable)(value, newSize, null));
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  });
+}
+function resizePairwise(store, resizingInfo, args) {
+  var _resizingInfo$sizeFor = resizingInfo.sizeForLinksVariables.map(function (expression) {
+      return (0, _number.forceInt)(store.run((0, _vtl.getExpressionAsString)(expression)));
+    }),
+    _resizingInfo$sizeFor2 = _slicedToArray(_resizingInfo$sizeFor, 2),
+    xSize = _resizingInfo$sizeFor2[0],
+    ySize = _resizingInfo$sizeFor2[1];
+  resizingInfo.linksVariables.forEach(function (variable) {
+    var value = store.get(variable, args.iteration);
+    var resizedValue = (0, _array.resizeArray)(
+    // The value is not an array, force an array
+    Array.isArray(value) ? value.map(function (i) {
+      return (0, _array.resizeArray)(i, ySize, null);
+    }) : [], xSize, new Array(ySize).fill(null));
+    store.set(variable, resizedValue);
+  });
+}

package/lib/use-lunatic/{reducer/reduce-handle-change/reduce-variables-array.js → commons/variables/get-questionnaire-data.js}

@@ -1,44 +1,65 @@
 "use strict";
 
-function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports["default"] = void 0;
-var _commons = require("../commons");
+exports.getQuestionnaireData = getQuestionnaireData;
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+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(_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 e(_e2) { didErr = true; err = _e2; }, 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(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 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 _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
 function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-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 _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 _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 _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; }
-/**
- * Inject the value at a specific index (and resize the value if necessary)
- */
-function reduceVariablesArray(variables, args) {
-  var name = args.name,
-    value = args.value,
-    index = args.index,
-    length = args.length;
-  if (name in variables) {
-    var variable = variables[name];
-    var previousValue = variable.value;
-
-    // Ensure the value is an array of corresponding size
-    var valueNext = _toConsumableArray((0, _commons.resizeArrayVariable)(previousValue, length));
+function getQuestionnaireData(store, variables) {
+  var withCalculated = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var variableNames = arguments.length > 3 ? arguments[3] : undefined;
+  var result = {
+    EXTERNAL: {},
+    CALCULATED: {},
+    COLLECTED: {}
+  };
+  if (!variables) {
+    return result;
+  }
 
-    // Inject the new value at the corresponding index
-    valueNext[index] = value;
-    return _objectSpread(_objectSpread({}, variables), {}, _defineProperty({}, name, _objectSpread(_objectSpread({}, variable), {}, {
-      value: valueNext
-    })));
+  // Only return requested variables
+  if (variableNames) {
+    return _objectSpread(_objectSpread({}, result), {}, {
+      COLLECTED: Object.fromEntries(variableNames.map(function (name) {
+        return [name, {
+          EDITED: null,
+          FORCED: null,
+          INPUTED: null,
+          PREVIOUS: null,
+          COLLECTED: store.get(name)
+        }];
+      }))
+    });
+  }
+  var _iterator = _createForOfIteratorHelper(variables),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var variable = _step.value;
+      // Skip calculated value if necessary
+      if (variable.variableType === 'CALCULATED' && !withCalculated) {
+        continue;
+      }
+      if (variable.variableType === 'COLLECTED') {
+        result.COLLECTED[variable.name] = _objectSpread(_objectSpread({}, variable.values), {}, {
+          COLLECTED: store.get(variable.name)
+        });
+      } else {
+        result[variable.variableType][variable.name] = store.get(variable.name);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
   }
-  return variables;
-}
-var _default = reduceVariablesArray;
-exports["default"] = _default;
+  return result;
+}

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

@@ -0,0 +1,330 @@
+"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(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+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(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+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(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+// Interpret counter, used for testing purpose
+var interpretCount = 0;
+var LunaticVariablesStore = /*#__PURE__*/function () {
+  function LunaticVariablesStore() {
+    _classCallCheck(this, LunaticVariablesStore);
+    this.dictionary = new Map();
+    this.eventTarget = new EventTarget();
+    interpretCount = 0;
+  }
+  _createClass(LunaticVariablesStore, [{
+    key: "get",
+    value:
+    /**
+     * Retrieve variable value
+     */
+    function 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;
+    }
+
+    /**
+     * 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;
+      if (this.dictionary.has(name)) {
+        return this.dictionary.get(name);
+      }
+      var variable = new LunaticVariable({
+        expression: expression,
+        dictionary: this.dictionary,
+        dependencies: dependencies,
+        iterationDepth: iterationDepth,
+        name: 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);
+    }
+
+    /**
+     * Bind event listeners
+     */
+  }, {
+    key: "on",
+    value: function on(eventName, cb) {
+      this.eventTarget.addEventListener(eventName, cb);
+    }
+
+    /**
+     * Detach a listener
+     */
+  }, {
+    key: "off",
+    value: function 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;
+    }
+  }], [{
+    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)
+              });
+              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, _resizingBehaviour.resizingBehaviour)(store, source.resizing);
+      (0, _cleaningBehaviour.cleaningBehaviour)(store, source.cleaning, initialValues);
+      (0, _missingBehaviour.missingBehaviour)(store, source.missingBlock);
+      return store;
+    }
+  }]);
+  return LunaticVariablesStore;
+}();
+exports.LunaticVariablesStore = LunaticVariablesStore;
+var LunaticVariable = /*#__PURE__*/function () {
+  function LunaticVariable() {
+    var _args$name;
+    var args = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, LunaticVariable);
+    // Last time the value was updated (changed)
+    this.updatedAt = new Map();
+    // Last time "calculation" was run (for calculated variable)
+    this.calculatedAt = new Map();
+    // Internal value for the variable
+    this.value = void 0;
+    // List of dependencies, ex: ['FIRSTNAME', 'LASTNAME']
+    this.dependencies = void 0;
+    // Expression for calculated variable
+    this.expression = void 0;
+    // Dictionary holding all the available variables
+    this.dictionary = void 0;
+    // Specific iteration depth to get value from dependencies (used for yAxis for instance)
+    this.iterationDepth = void 0;
+    // 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");
+    }
+    this.expression = args.expression;
+    this.dictionary = args.dictionary;
+    this.dependencies = args.dependencies;
+    this.iterationDepth = args.iterationDepth;
+    this.name = (_args$name = args.name) !== null && _args$name !== void 0 ? _args$name : args.expression;
+  }
+  _createClass(LunaticVariable, [{
+    key: "getValue",
+    value: function getValue(iteration) {
+      // The variable is not calculated
+      if (!this.expression) {
+        return this.getSavedValue(iteration);
+      }
+      // Calculate bindings first to refresh "updatedAt" on calculated dependencies
+      var bindings = this.getDependenciesValues(iteration);
+      if (!this.isOutdated(iteration)) {
+        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.calculatedAt.set(iteration === null || iteration === void 0 ? void 0 : iteration.join('.'), performance.now());
+      this.calculatedAt.set(undefined, performance.now());
+      return this.getSavedValue(iteration);
+    }
+
+    /**
+     * Set the value and returns true if the variable is touched
+     */
+  }, {
+    key: "setValue",
+    value: function setValue(value, iteration) {
+      var _this = this;
+      if (value === this.getSavedValue(iteration)) {
+        return false;
+      }
+      // Decompose arrays, to only update items that changed
+      if (Array.isArray(value) && !Array.isArray(iteration)) {
+        return !!value.map(function (v, k) {
+          return _this.setValue(v, [k]);
+        }).find(function (v) {
+          return v;
+        });
+      }
+      // 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.updatedAt.set(iteration === null || iteration === void 0 ? void 0 : iteration.join('.'), performance.now());
+      this.updatedAt.set(undefined, performance.now());
+      return true;
+    }
+  }, {
+    key: "getSavedValue",
+    value: function getSavedValue(iteration) {
+      if (!Array.isArray(iteration)) {
+        return this.value;
+      }
+      var current = this.value;
+      var _iterator2 = _createForOfIteratorHelper(iteration),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var index = _step2.value;
+          if (!Array.isArray(current)) {
+            return current;
+          }
+          current = current[index];
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      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;
+    }
+  }, {
+    key: "getDependenciesValues",
+    value: function getDependenciesValues(iteration) {
+      var _this2 = this;
+      try {
+        return Object.fromEntries(this.getDependencies().map(function (dep) {
+          var _this2$dictionary;
+          var dependencyIteration = (0, _number.isNumber)(_this2.iterationDepth) && Array.isArray(iteration) ? [iteration[_this2.iterationDepth]] : iteration;
+          return [dep, (_this2$dictionary = _this2.dictionary) === null || _this2$dictionary === void 0 || (_this2$dictionary = _this2$dictionary.get(dep)) === null || _this2$dictionary === void 0 ? void 0 : _this2$dictionary.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()));
+        }
+        throw e;
+      }
+    }
+  }, {
+    key: "isOutdated",
+    value: function isOutdated(iteration) {
+      var _this3 = this,
+        _this$calculatedAt$ge;
+      var dependenciesUpdatedAt = Math.max.apply(Math, [0].concat(_toConsumableArray(this.getDependencies().map(function (dep) {
+        var _this3$dictionary$get, _this3$dictionary;
+        return (_this3$dictionary$get = (_this3$dictionary = _this3.dictionary) === null || _this3$dictionary === void 0 || (_this3$dictionary = _this3$dictionary.get(dep)) === null || _this3$dictionary === void 0 ? void 0 : _this3$dictionary.updatedAt.get(iteration === null || iteration === void 0 ? void 0 : iteration.join('.'))) !== null && _this3$dictionary$get !== void 0 ? _this3$dictionary$get : 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);
+    }
+  }]);
+  return LunaticVariable;
+}();