@wavemaker/react-runtime 11.14.1-rc.236

package/utils/widget-cleanup-util.js

@@ -0,0 +1,84 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createWidgetCleanup = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+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) { (0, _defineProperty2["default"])(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; }
+/**
+ * Configuration for the widget cleanup utility
+ */
+
+/**
+ * Creates a debounced widget cleanup utility function
+ * This eliminates code duplication between WidgetProvider and BasePage
+ *
+ * @param config - Configuration object for the cleanup utility
+ * @returns Object containing cleanup function and cleanupRef
+ */
+var createWidgetCleanup = exports.createWidgetCleanup = function createWidgetCleanup(config) {
+  var setPageContext = config.setPageContext,
+    proxyRef = config.proxyRef,
+    _config$debounceDelay = config.debounceDelay,
+    debounceDelay = _config$debounceDelay === void 0 ? 100 : _config$debounceDelay;
+  var cleanupRef = new Set();
+  var timeoutId = null;
+
+  // Debounced cleanup function that processes accumulated widget names
+  var performCleanup = function performCleanup() {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(function () {
+      if (cleanupRef.size === 0) return;
+      setPageContext(function (currentContext) {
+        var newContext = _objectSpread({}, currentContext);
+        var widgetsToClean = (0, _toConsumableArray2["default"])(cleanupRef);
+        widgetsToClean.forEach(function (name) {
+          if (newContext.Widgets && newContext.Widgets[name]) {
+            var _proxyRef$current;
+            delete newContext.Widgets[name];
+
+            // Delete from proxy if available
+            if (proxyRef !== null && proxyRef !== void 0 && (_proxyRef$current = proxyRef.current) !== null && _proxyRef$current !== void 0 && _proxyRef$current.Widgets) {
+              delete proxyRef.current.Widgets[name];
+            }
+          }
+        });
+        cleanupRef.clear();
+        return newContext;
+      });
+      timeoutId = null;
+    }, debounceDelay);
+  };
+
+  /**
+   * Cleanup function to be called when a widget needs to be removed
+   * @param name - Name of the widget to cleanup
+   */
+  var cleanup = function cleanup(name) {
+    // Accumulate widget names to be cleaned up
+    cleanupRef.add(name);
+    // Trigger debounced cleanup
+    performCleanup();
+  };
+
+  /**
+   * Cancel any pending cleanup operations
+   */
+  var cancel = function cancel() {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  return {
+    cleanup: cleanup,
+    cleanupRef: cleanupRef,
+    cancel: cancel
+  };
+};

package/utils/widgets.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getObjValueByKey = exports.getEvaluatedData = exports.checkIsCustomPipeExpression = void 0;
+var _lodashEs = require("lodash-es");
+var getObjValueByKey = exports.getObjValueByKey = function getObjValueByKey(obj, strKey) {
+  if (!strKey || !obj) {
+    return obj;
+  }
+  return (0, _lodashEs.get)(obj, strKey);
+};
+var checkIsCustomPipeExpression = exports.checkIsCustomPipeExpression = function checkIsCustomPipeExpression(exp) {
+  var customRegEx = /(custom(\s*:))/g;
+  var matches = exp.match(customRegEx);
+  return matches && matches.length;
+};
+var getEvaluatedData = exports.getEvaluatedData = function getEvaluatedData(dataObj, options, context) {
+  var displayExpr = options.expression;
+  if (displayExpr) {
+    if (typeof displayExpr !== "function") {
+      return dataObj[displayExpr];
+    }
+    return displayExpr(dataObj);
+  }
+  var expressionValue = "";
+  var field = options.field || "",
+    expr = options.expression,
+    bindExpr = options.bindExpression;
+  if (bindExpr) {
+    expressionValue = bindExpr.replace("bind:", "");
+    if (checkIsCustomPipeExpression(expressionValue)) {
+      expressionValue = expressionValue + ": __1";
+    }
+    expressionValue = getUpdatedExpr(expressionValue);
+  } else {
+    expressionValue = expr ? expr : field;
+  }
+  if (!bindExpr && !expr) {
+    if (typeof field === "function") {
+      return field(dataObj);
+    }
+    return (0, _lodashEs.get)(dataObj, field);
+  }
+  return expressionValue(context, Object.assign({}, dataObj, {
+    __1: dataObj
+  }));
+};
+var getUpdatedExpr = function getUpdatedExpr(expr) {
+  var updated = "",
+    ch,
+    next,
+    i,
+    j,
+    matchCh,
+    matchCount,
+    isQuotedStr,
+    subStr,
+    isQuotedStrEvaluated;
+  expr = expr.replace(/\$\[data\[\$i\]/g, "$[__1");
+  for (i = 0; i < expr.length; i++) {
+    ch = expr[i];
+    next = expr[i + 1];
+    if (ch === "$" && next === "[") {
+      matchCount = 1;
+      isQuotedStrEvaluated = false;
+      isQuotedStr = false;
+      for (j = i + 2; j < expr.length; j++) {
+        matchCh = expr[j];
+        if (matchCh === " ") {
+          continue;
+        }
+        if (!isQuotedStrEvaluated) {
+          isQuotedStr = expr[j] === '"' || expr[j] === "'";
+          isQuotedStrEvaluated = true;
+        }
+        if (matchCh === "[") {
+          matchCount++;
+        } else if (matchCh === "]") {
+          matchCount--;
+        }
+        if (!matchCount) {
+          subStr = expr.substring(i + 2, j);
+          if (isQuotedStr) {
+            updated += "__1[" + subStr + "]";
+          } else {
+            updated += subStr;
+          }
+          break;
+        }
+      }
+      i = j;
+    } else {
+      updated += ch;
+    }
+  }
+  return updated;
+};

package/variables/base-variable.js

@@ -0,0 +1,173 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VariableEvents = exports.BaseVariable = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _datasetUtil = _interopRequireDefault(require("@wavemaker/react-runtime/utils/dataset-util"));
+var _eventNotifier = _interopRequireDefault(require("@wavemaker/react-runtime/core/event-notifier"));
+var _lodashEs = require("lodash-es");
+function _createSuper(t) { var r = _isNativeReflectConstruct(); return function () { var e, o = (0, _getPrototypeOf2["default"])(t); if (r) { var s = (0, _getPrototypeOf2["default"])(this).constructor; e = Reflect.construct(o, arguments, s); } else e = o.apply(this, arguments); return (0, _possibleConstructorReturn2["default"])(this, e); }; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+var VariableEvents = exports.VariableEvents = /*#__PURE__*/function (VariableEvents) {
+  VariableEvents["BEFORE_INVOKE"] = "beforeInvoke";
+  VariableEvents["SUCCESS"] = "success";
+  VariableEvents["ERROR"] = "error";
+  VariableEvents["AFTER_INVOKE"] = "afterInvoke";
+  return VariableEvents;
+}({});
+var BaseVariable = exports.BaseVariable = /*#__PURE__*/function (_EventNotifier) {
+  (0, _inherits2["default"])(BaseVariable, _EventNotifier);
+  var _super = _createSuper(BaseVariable);
+  function BaseVariable(config) {
+    var _this;
+    (0, _classCallCheck2["default"])(this, BaseVariable);
+    _this = _super.call(this);
+    _this.config = config;
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "name", "");
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "params", {});
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "dataSet", {});
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "isList", void 0);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "twoWayBinding", void 0);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "isExecuting", false);
+    _this.name = config.name;
+    _this.isList = config.isList;
+    _this.twoWayBinding = config.twoWayBinding;
+    _this.dataSet = _this.isList ? [] : _this.dataSet;
+    _this.subscribe(VariableEvents.BEFORE_INVOKE, function () {
+      _this.isExecuting = true;
+      console.info("Before Invoking variable ".concat(_this.name));
+    });
+    _this.subscribe(VariableEvents.AFTER_INVOKE, function () {
+      _this.isExecuting = false;
+      console.info("After Invoking variable ".concat(_this.name));
+    });
+    return _this;
+  }
+  (0, _createClass2["default"])(BaseVariable, [{
+    key: "invoke",
+    value: function invoke(params, onSuccess, onError) {
+      if (!params) {
+        this.params = this.config.paramProvider();
+      } else {
+        this.params = params;
+      }
+      return Promise.resolve(this);
+    }
+  }, {
+    key: "doNext",
+    value: function doNext() {
+      return Promise.reject(this);
+    }
+  }, {
+    key: "invokeOnParamChange",
+    value: function invokeOnParamChange() {
+      var last = this.params;
+      var latest = this.config.paramProvider();
+      if (!(0, _lodashEs.isEqual)(last, latest)) {
+        return this.invoke(latest);
+      }
+      return Promise.resolve(this);
+    }
+  }, {
+    key: "getData",
+    value: function getData() {
+      return this.dataSet;
+    }
+  }, {
+    key: "setData",
+    value: function setData(dataSet) {
+      if (_datasetUtil["default"].isValidDataset(dataSet, this.isList)) {
+        this.dataSet = dataSet;
+      }
+      return this.dataSet;
+    }
+  }, {
+    key: "getValue",
+    value: function getValue(key, index) {
+      return _datasetUtil["default"].getValue(this.dataSet, key, index, this.isList);
+    }
+  }, {
+    key: "setValue",
+    value: function setValue(key, value) {
+      return _datasetUtil["default"].setValue(this.dataSet, key, value, this.isList);
+    }
+  }, {
+    key: "getItem",
+    value: function getItem(index) {
+      return _datasetUtil["default"].getItem(this.dataSet, index, this.isList);
+    }
+  }, {
+    key: "setItem",
+    value: function setItem(index, value, options) {
+      options = _datasetUtil["default"].getChildDetails(this.dataSet, options, this.isList);
+      return _datasetUtil["default"].setItem(this.dataSet, index, value, options);
+    }
+  }, {
+    key: "addItem",
+    value: function addItem(value, options) {
+      var index;
+      if ((0, _lodashEs.isNumber)(options)) {
+        index = options;
+      }
+      if ((0, _lodashEs.isObject)(options)) {
+        // @ts-ignore
+        index = options.index;
+      }
+      options = _datasetUtil["default"].getChildDetails(this.dataSet, options, this.isList);
+      return _datasetUtil["default"].addItem(this.dataSet, value, index, options);
+    }
+  }, {
+    key: "removeItem",
+    value: function removeItem(index, options) {
+      var exactMatch, parentIndex;
+      if (options) {
+        if ((0, _lodashEs.isBoolean)(options)) {
+          exactMatch = options;
+        }
+        if ((0, _lodashEs.isObject)(options)) {
+          // @ts-ignore
+          exactMatch = options.exactMatch;
+          if (this.isList) {
+            // @ts-ignore
+            parentIndex = options.parentIndex || 0;
+          }
+        }
+      }
+      return _datasetUtil["default"].removeItem(this.dataSet, index, {
+        exactMatch: exactMatch,
+        path: (0, _lodashEs.get)(options, "path"),
+        parentIndex: parentIndex
+      });
+    }
+  }, {
+    key: "clearData",
+    value: function clearData() {
+      this.dataSet = _datasetUtil["default"].getValidDataset(this.isList);
+      return this.dataSet;
+    }
+  }, {
+    key: "getCount",
+    value: function getCount() {
+      return _datasetUtil["default"].getCount(this.dataSet, this.isList);
+    }
+  }, {
+    key: "pause",
+    value: function pause() {}
+  }, {
+    key: "resume",
+    value: function resume() {}
+  }, {
+    key: "destroy",
+    value: function destroy() {}
+  }]);
+  return BaseVariable;
+}(_eventNotifier["default"]);

package/variables/constants.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WS_CONSTANTS = void 0;
+var WS_CONSTANTS = exports.WS_CONSTANTS = {
+  NON_BODY_HTTP_METHODS: ["GET", "HEAD"],
+  NON_DATA_AXIOS_METHODS: ["GET", "DELETE", "HEAD", "OPTIONS"],
+  CONTENT_TYPES: {
+    FORM_URL_ENCODED: "application/x-www-form-urlencoded",
+    MULTIPART_FORMDATA: "multipart/form-data",
+    OCTET_STREAM: "application/octet-stream"
+  },
+  REST_SERVICE: {
+    ERR_TYPE: {
+      METADATA_MISSING: "metadata_missing",
+      CRUD_OPERATION_MISSING: "crud_operation_missing",
+      USER_UNAUTHORISED: "user_unauthorised"
+    },
+    ERR_MSG: {
+      METADATA_MISSING: 'Metadata missing for "$variable"',
+      USER_UNAUTHORISED: "Unauthorized User",
+      CRUD_OPERATION_MISSING: 'Operation "$operation" not allowed for "$variable"'
+    }
+  }
+};

package/variables/live-variable.js

@@ -0,0 +1,166 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _baseVariable = require("./base-variable");
+var _lodashEs = require("lodash-es");
+var _variables = require("@wavemaker/variables");
+var _useHttp = _interopRequireDefault(require("@wavemaker/react-runtime/hooks/useHttp"));
+var _util = require("@wavemaker/react-runtime/core/util");
+var _formatters = _interopRequireDefault(require("@wavemaker/react-runtime/core/formatters"));
+function _createSuper(t) { var r = _isNativeReflectConstruct(); return function () { var e, o = (0, _getPrototypeOf2["default"])(t); if (r) { var s = (0, _getPrototypeOf2["default"])(this).constructor; e = Reflect.construct(o, arguments, s); } else e = o.apply(this, arguments); return (0, _possibleConstructorReturn2["default"])(this, e); }; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); } // @ts-ignore
+var _LiveVariableEvents = /*#__PURE__*/function (_LiveVariableEvents) {
+  _LiveVariableEvents["BEFORE_INVOKE"] = "beforeInvoke";
+  return _LiveVariableEvents;
+}(_LiveVariableEvents || {});
+var LiveVariable = /*#__PURE__*/function (_LiveVariable3) {
+  (0, _inherits2["default"])(LiveVariable, _LiveVariable3);
+  var _super = _createSuper(LiveVariable);
+  function LiveVariable(config) {
+    var _this;
+    (0, _classCallCheck2["default"])(this, LiveVariable);
+    var variableConfig = {
+      name: config.name,
+      dataSet: config.paramProvider(),
+      inputFields: config.paramProvider(),
+      filterExpressions: config.filterExpressions,
+      filterFields: config.paramProvider(),
+      isList: config.isList,
+      maxResults: config.maxResults,
+      _context: config._context,
+      operation: config.operation,
+      type: config.type,
+      autoUpdate: config.autoUpdate,
+      liveSource: config.liveSource,
+      orderBy: config.orderBy,
+      category: config.category,
+      properties: config.properties,
+      propertiesMap: config.propertiesMap,
+      tableName: config.tableName,
+      tableType: config.tableType,
+      relatedTables: config.relatedTables,
+      httpClientService: _useHttp["default"],
+      inFlightBehavior: config.inFlightBehavior,
+      _id: config._id,
+      onSuccess: function onSuccess(context, args) {
+        _this.notify(_baseVariable.VariableEvents.AFTER_INVOKE, [args.variable, args.data, args.options]);
+        _this.notify(_baseVariable.VariableEvents.SUCCESS, [args.variable, args.data, args.options]);
+        return config.onSuccess && config.onSuccess(args.variable, args.data, args.options);
+      },
+      onCanUpdate: function onCanUpdate(context, args) {
+        return config.onCanUpdate && config.onCanUpdate(args.variable, args.data, args.options);
+      },
+      onBeforeUpdate: function onBeforeUpdate(context, args) {
+        return config.onBeforeUpdate && config.onBeforeUpdate(args.variable, args.dataFilter || args.inputData, args.options);
+      },
+      onResult: function onResult(context, args) {
+        _this.notify(_baseVariable.VariableEvents.AFTER_INVOKE, [args.variable, args.data, args.options]);
+        return config.onResult && config.onResult(args.variable, args.data, args.options);
+      },
+      onBeforeDatasetReady: function onBeforeDatasetReady(context, args) {
+        return config.onBeforeDatasetReady && config.onBeforeDatasetReady(args.variable, args.data, args.options);
+      },
+      onError: function onError(context, args) {
+        _this.notify(_baseVariable.VariableEvents.AFTER_INVOKE, [args.variable, args.data, args.options]);
+        _this.notify(_baseVariable.VariableEvents.ERROR, [args.variable, args.data, args.options]);
+        return config.onError && config.onError(args.variable, args.data, args.options);
+      }
+    };
+    _this = _super.call(this, variableConfig);
+    _this.config = config;
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "params", {});
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "filters", {});
+    _this.dateFormatter = _formatters["default"].get("toDate");
+    _this.init();
+    return _this;
+  }
+  (0, _createClass2["default"])(LiveVariable, [{
+    key: "setFilterExpValue",
+    value: function setFilterExpValue(filter) {
+      var _this$filterExpressio;
+      (_this$filterExpressio = this.filterExpressions) === null || _this$filterExpressio === void 0 || _this$filterExpressio.rules.forEach(function (r) {
+        r.value = filter[r.target];
+      });
+    }
+  }, {
+    key: "invokeOnParamChange",
+    value: function invokeOnParamChange() {
+      var _this2 = this;
+      var last = this.params;
+      var latest = this.config.paramProvider();
+      if (this.config.operation === "read") {
+        var lastFilter = this.filters;
+        var latestFilter = this.config.filterProvider && this.config.filterProvider();
+        if (!(0, _lodashEs.isEqual)(lastFilter, latestFilter)) {
+          this.setFilterExpValue(latestFilter);
+          if (this.autoUpdate && !(0, _lodashEs.isEmpty)(latestFilter) && (0, _lodashEs.isFunction)(this.update)) {
+            this.filters = latestFilter;
+            this.invoke();
+          }
+        }
+      }
+      if (!(0, _lodashEs.isEqual)(last, latest)) {
+        if (this.config.operation === "read") {
+          (0, _lodashEs.forEach)(latest, function (val, key) {
+            _this2.filterFields[key] = {
+              value: val
+            };
+          });
+        } else {
+          this.inputFields = latest;
+        }
+        /* if auto-update set for the variable with read operation only, get its data */
+        // @ts-ignore
+        if (this.autoUpdate && !(0, _lodashEs.isUndefined)(latest) && (0, _lodashEs.isFunction)(this[this.config.operation + "Record"])) {
+          this.invoke();
+        }
+      }
+      return Promise.resolve(this);
+    }
+  }, {
+    key: "listRecords",
+    value: function listRecords(options, onSuccess, onError) {
+      this.notify(_baseVariable.VariableEvents.BEFORE_INVOKE, [this]);
+      this.filters = this.config.filterProvider && this.config.filterProvider();
+      if (options) {
+        this.filters = (0, _util.deepCopy)({}, this.filters, options.filterFields ? options.filterFields : options);
+      }
+      options = options || {};
+      options.filterFields = this.filters;
+      this.setFilterExpValue(this.filters);
+      return (0, _get2["default"])((0, _getPrototypeOf2["default"])(LiveVariable.prototype), "listRecords", this).call(this, options, onSuccess, onError);
+    }
+  }, {
+    key: "updateRecord",
+    value: function updateRecord(options, success, error) {
+      this.notify(_baseVariable.VariableEvents.BEFORE_INVOKE, [this]);
+      return (0, _get2["default"])((0, _getPrototypeOf2["default"])(LiveVariable.prototype), "updateRecord", this).call(this, options, success, error);
+    }
+  }, {
+    key: "insertRecord",
+    value: function insertRecord(options, success, error) {
+      this.notify(_baseVariable.VariableEvents.BEFORE_INVOKE, [this]);
+      return (0, _get2["default"])((0, _getPrototypeOf2["default"])(LiveVariable.prototype), "insertRecord", this).call(this, options, success, error);
+    }
+  }, {
+    key: "deleteRecord",
+    value: function deleteRecord(options, success, error) {
+      this.notify(_baseVariable.VariableEvents.BEFORE_INVOKE, [this]);
+      return (0, _get2["default"])((0, _getPrototypeOf2["default"])(LiveVariable.prototype), "deleteRecord", this).call(this, options, success, error);
+    }
+  }]);
+  return LiveVariable;
+}(_variables.LiveVariable);
+var _default = exports["default"] = LiveVariable;

package/variables/model-variable.js

@@ -0,0 +1,77 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ModelVariable = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _lodashEs = require("lodash-es");
+var _baseVariable = require("./base-variable");
+var _variables = require("@wavemaker/variables");
+function _createSuper(t) { var r = _isNativeReflectConstruct(); return function () { var e, o = (0, _getPrototypeOf2["default"])(t); if (r) { var s = (0, _getPrototypeOf2["default"])(this).constructor; e = Reflect.construct(o, arguments, s); } else e = o.apply(this, arguments); return (0, _possibleConstructorReturn2["default"])(this, e); }; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+var ModelVariable = exports.ModelVariable = /*#__PURE__*/function (_ModelVariable3) {
+  (0, _inherits2["default"])(ModelVariable, _ModelVariable3);
+  var _super = _createSuper(ModelVariable);
+  function ModelVariable(config) {
+    var _this;
+    (0, _classCallCheck2["default"])(this, ModelVariable);
+    // Initialize with empty dataset first
+    var variable = {
+      name: config.name,
+      dataSet: config.paramProvider() || {
+        dataValue: ""
+      },
+      // Default empty value
+      isList: config.isList,
+      twoWayBinding: config.twoWayBinding
+    };
+    _this = _super.call(this, variable);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "config", void 0);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "lastParams", void 0);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "dataSet", void 0);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "initialized", false);
+    _this.config = config;
+    _this.invoke();
+    return _this;
+  }
+  (0, _createClass2["default"])(ModelVariable, [{
+    key: "invoke",
+    value: function invoke(params, onSuccess, onError) {
+      var result;
+      try {
+        this.dataSet = this.config.paramProvider();
+        this.notify(_baseVariable.VariableEvents.BEFORE_INVOKE, [this, this.dataSet]);
+        result = (0, _get2["default"])((0, _getPrototypeOf2["default"])(ModelVariable.prototype), "execute", this).call(this, params, function () {});
+        this.config.onSuccess && this.config.onSuccess(this, this.dataSet);
+        onSuccess && onSuccess(this, this.dataSet);
+        this.notify(_baseVariable.VariableEvents.SUCCESS, [this, this.dataSet]);
+      } catch (error) {
+        this.config.onError && this.config.onError(this, this.dataSet);
+        onError && onError(this, this.dataSet);
+        this.notify(_baseVariable.VariableEvents.ERROR, [this, this.dataSet]);
+      }
+      this.notify(_baseVariable.VariableEvents.AFTER_INVOKE, [this, this.dataSet]);
+      return result;
+    }
+  }, {
+    key: "invokeOnParamChange",
+    value: function invokeOnParamChange() {
+      var latest = this.config.paramProvider();
+      if (!(0, _lodashEs.isEqual)(this.lastParams, latest)) {
+        this.invoke();
+        this.lastParams = (0, _lodashEs.clone)(latest);
+      }
+      return Promise.resolve(this);
+    }
+  }]);
+  return ModelVariable;
+}(_variables.ModelVariable);