@olenbetong/react-data-object-connect/dist/data-object-connect.umd.js

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
  typeof define === 'function' && define.amd ? define(['exports'], factory) :
  (global = global || self, factory(global.dataObjectConnect = {}));
}(this, function (exports) { 'use strict';

  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, descriptor.key, descriptor);
    }
  }

  function _createClass(Constructor, protoProps, staticProps) {
    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
    if (staticProps) _defineProperties(Constructor, staticProps);
    return Constructor;
  }

  function _extends() {
    _extends = Object.assign || function (target) {
      for (var i = 1; i < arguments.length; i++) {
        var source = arguments[i];

        for (var key in source) {
          if (Object.prototype.hasOwnProperty.call(source, key)) {
            target[key] = source[key];
          }
        }
      }

      return target;
    };

    return _extends.apply(this, arguments);
  }

  function _inherits(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
      throw new TypeError("Super expression must either be null or a function");
    }

    subClass.prototype = Object.create(superClass && superClass.prototype, {
      constructor: {
        value: subClass,
        writable: true,
        configurable: true
      }
    });
    if (superClass) _setPrototypeOf(subClass, superClass);
  }

  function _getPrototypeOf(o) {
    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
      return o.__proto__ || Object.getPrototypeOf(o);
    };
    return _getPrototypeOf(o);
  }

  function _setPrototypeOf(o, p) {
    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
      o.__proto__ = p;
      return o;
    };

    return _setPrototypeOf(o, p);
  }

  function _assertThisInitialized(self) {
    if (self === void 0) {
      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }

    return self;
  }

  function _possibleConstructorReturn(self, call) {
    if (call && (typeof call === "object" || typeof call === "function")) {
      return call;
    }

    return _assertThisInitialized(self);
  }

  const { React } = window;
  const PureComponent = React.PureComponent;
  const Component = React.Component;
  const useState = React.useState;
  const useEffect = React.useEffect;

  var events = ["AllowDeleteChanged", "AllowUpdateChanged", "AllowInsertChanged", "SaveFailed", "PartialDataLoaded", "DataLoadFailed", "FieldChanged", "RecordCreated", "RecordRefreshed", "RecordDeleting", "RecordDeleted", "AfterSave", "BeforeLoad", "BeforeSave", "CancelEdit", "CurrentIndexChanged", "DataLoaded", "DirtyChanged"];
  function dataObjectConnect(dataObject) {
    var currentRowOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
    return function connect(WrappedComponent) {
      function getDataObject() {
        return typeof dataObject === "string" ? window[dataObject] : dataObject;
      }

      var connector =
      /*#__PURE__*/
      function (_React$Component) {
        _inherits(connector, _React$Component);

        function connector(props) {
          var _this;

          _classCallCheck(this, connector);

          _this = _possibleConstructorReturn(this, _getPrototypeOf(connector).call(this, props));
          var initialState = {};
          var dataObject = getDataObject();

          if (currentRowOnly) {
            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

            try {
              for (var _iterator = dataObject.getFields()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                var field = _step.value;
                initialState[field.name] = null;
              }
            } catch (err) {
              _didIteratorError = true;
              _iteratorError = err;
            } finally {
              try {
                if (!_iteratorNormalCompletion && _iterator.return != null) {
                  _iterator.return();
                }
              } finally {
                if (_didIteratorError) {
                  throw _iteratorError;
                }
              }
            }
          } else {
            initialState.data = [];
          }

          _this.state = Object.assign({
            canDelete: dataObject.isDeleteAllowed(),
            canUpdate: dataObject.isUpdateAllowed(),
            canInsert: dataObject.isInsertAllowed(),
            currentIndex: dataObject.getCurrentIndex(),
            isDirty: dataObject.isDirty(),
            isDeleting: false,
            isLoading: dataObject.isDataLoading() === true,
            isSaving: false,
            loadError: null,
            saveFailed: false
          }, initialState);
          _this.handleAfterSave = _this.handleAfterSave.bind(_assertThisInitialized(_assertThisInitialized(_this)));
          _this.handleAllowDeleteChanged = _this.handleAllowDeleteChanged.bind(_assertThisInitialized(_assertThisInitialized(_this)));
          _this.handleAllowInsertChanged = _this.handleAllowInsertChanged.bind(_assertThisInitialized(_assertThisInitialized(_this)));
          _this.handleAllowUpdateChanged = _this.handleAllowUpdateChanged.bind(_assertThisInitialized(_assertThisInitialized(_this)));
          _this.handleBeforeLoad = _this.handleBeforeLoad.bind(_assertThisInitialized(_assertThisInitialized(_this)));
          _this.handleBeforeSave = _this.handleBeforeSave.bind(_assertThisInitialized(_assertThisInitialized(_this)));
          _this.handleCancelEdit = _this.handleCancelEdit.bind(_assertThisInitialized(_assertThisInitialized(_this)));
          _this.handleCurrentIndexChanged = _this.handleCurrentIndexChanged.bind(_assertThisInitialized(_assertThisInitialized(_this)));
          _this.handleDataLoaded = _this.handleDataLoaded.bind(_assertThisInitialized(_assertThisInitialized(_this)));
          _this.handleDataLoadFailed = _this.handleDataLoadFailed.bind(_assertThisInitialized(_assertThisInitialized(_this)));
          _this.handleDirtyChanged = _this.handleDirtyChanged.bind(_assertThisInitialized(_assertThisInitialized(_this)));
          _this.handlePartialDataLoaded = _this.handlePartialDataLoaded.bind(_assertThisInitialized(_assertThisInitialized(_this)));
          _this.handleRecordDeleting = _this.handleRecordDeleting.bind(_assertThisInitialized(_assertThisInitialized(_this)));
          _this.handleRecordDeleted = _this.handleRecordDeleted.bind(_assertThisInitialized(_assertThisInitialized(_this)));
          _this.handleSaveFailed = _this.handleSaveFailed.bind(_assertThisInitialized(_assertThisInitialized(_this)));
          _this.setFieldValue = _this.setFieldValue.bind(_assertThisInitialized(_assertThisInitialized(_this)));
          _this.setFieldValues = _this.setFieldValues.bind(_assertThisInitialized(_assertThisInitialized(_this)));
          _this.updateData = _this.updateData.bind(_assertThisInitialized(_assertThisInitialized(_this)));
          _this.handleFieldChanged = _this.updateData;
          _this.handleRecordCreated = _this.updateData;
          _this.handleRecordRefreshed = _this.updateData;
          return _this;
        }

        _createClass(connector, [{
          key: "componentDidMount",
          value: function componentDidMount() {
            var dataObject = getDataObject();

            for (var _i = 0; _i < events.length; _i++) {
              var event = events[_i];
              dataObject.attachEvent("on" + event, this["handle" + event]);
            }

            this.updateData();
          }
        }, {
          key: "componentWillUnmount",
          value: function componentWillUnmount() {
            var dataObject = getDataObject();

            for (var _i2 = 0; _i2 < events.length; _i2++) {
              var event = events[_i2];
              dataObject.detachEvent("on" + event, this["handle" + event]);
            }
          }
        }, {
          key: "cancelEdit",
          value: function cancelEdit() {
            getDataObject().cancelEdit();
          }
        }, {
          key: "deleteRow",
          value: function deleteRow(idx) {
            var dataObject = getDataObject();
            return new Promise(function (resolve) {
              var callback = function callback(error, data) {
                resolve({
                  data: data,
                  error: error
                });
              };

              if (currentRowOnly) {
                dataObject.deleteCurrentRow(callback);
              } else {
                dataObject.deleteRow(idx, callback);
              }
            });
          }
        }, {
          key: "endEdit",
          value: function endEdit(callback) {
            var dataObject = getDataObject();
            return new Promise(function (resolve) {
              dataObject.endEdit(function (error, data) {
                "function" === typeof callback && callback(error, data);
                resolve({
                  data: data,
                  error: error
                });
              });
            });
          }
        }, {
          key: "updateData",
          value: function updateData() {
            var otherState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
            var dataObject = getDataObject();

            if (currentRowOnly) {
              var record = dataObject.currentRow();
              this.setState(Object.assign(record, otherState));
            } else {
              var data = dataObject.getData();
              var current = dataObject.currentRow();
              this.setState(Object.assign({
                current: current,
                data: data
              }, otherState));
            }
          }
        }, {
          key: "handleAllowDeleteChanged",
          value: function handleAllowDeleteChanged(allowed) {
            this.setState({
              canDelete: allowed
            });
          }
        }, {
          key: "handleAllowUpdateChanged",
          value: function handleAllowUpdateChanged(allowed) {
            this.setState({
              canUpdate: allowed
            });
          }
        }, {
          key: "handleAllowInsertChanged",
          value: function handleAllowInsertChanged(allowed) {
            this.setState({
              canInsert: allowed
            });
          }
        }, {
          key: "handleSaveFailed",
          value: function handleSaveFailed() {
            this.setState({
              saveFailed: true
            });
          }
        }, {
          key: "handlePartialDataLoaded",
          value: function handlePartialDataLoaded() {
            return null;
          }
        }, {
          key: "handleDataLoadFailed",
          value: function handleDataLoadFailed(loadError) {
            if (loadError) {
              this.setState({
                isLoading: false,
                loadError: loadError
              });
            } else {
              this.setState({
                isLoading: false
              });
            }
          }
        }, {
          key: "handleRecordDeleting",
          value: function handleRecordDeleting() {
            this.setState({
              isDeleting: true
            });
          }
        }, {
          key: "handleRecordDeleted",
          value: function handleRecordDeleted() {
            this.updateData({
              isDeleting: false
            });
          }
        }, {
          key: "handleAfterSave",
          value: function handleAfterSave() {
            this.updateData({
              isSaving: false
            });
          }
        }, {
          key: "handleBeforeLoad",
          value: function handleBeforeLoad() {
            this.setState({
              isLoading: true
            });
          }
        }, {
          key: "handleBeforeSave",
          value: function handleBeforeSave() {
            this.setState({
              isSaving: true,
              saveFailed: false
            });
          }
        }, {
          key: "handleCancelEdit",
          value: function handleCancelEdit() {
            this.updateData({
              isSaving: false
            });
          }
        }, {
          key: "handleCurrentIndexChanged",
          value: function handleCurrentIndexChanged(currentIndex) {
            if (currentRowOnly) {
              this.updateData();
            } else {
              this.updateData();
              this.setState({
                currentIndex: currentIndex
              });
            }
          }
        }, {
          key: "handleDataLoaded",
          value: function handleDataLoaded() {
            this.updateData({
              isLoading: false,
              isSaving: false,
              isDeleting: false,
              saveFailed: false
            });
          }
        }, {
          key: "handleDirtyChanged",
          value: function handleDirtyChanged() {
            this.setState({
              isDirty: getDataObject().isDirty()
            });
          }
        }, {
          key: "refreshData",
          value: function refreshData(callback) {
            var dataObject = getDataObject();
            return new Promise(function (resolve) {
              dataObject.refreshDataSource(function (error, data) {
                "function" === typeof callback && callback(error, data);
                resolve({
                  data: data,
                  error: error
                });
              });
            });
          }
        }, {
          key: "refreshRow",
          value: function refreshRow(callback) {
            var dataObject = getDataObject();
            return new Promise(function (resolve) {
              dataObject.refreshCurrentRow(function (error, data) {
                "function" === typeof callback && callback(error, data);
                resolve({
                  data: data,
                  error: error
                });
              });
            });
          }
        }, {
          key: "setFieldValue",
          value: function setFieldValue(name, value) {
            getDataObject().currentRow(name, value);
            this.updateData();
          }
        }, {
          key: "setFieldValues",
          value: function setFieldValues(fields) {
            var dataObject = getDataObject();

            for (var field in fields) {
              if (fields.hasOwnProperty(field)) {
                dataObject.currentRow(field, fields[field]);
              }
            }

            this.updateData();
          }
        }, {
          key: "setCurrentIndex",
          value: function setCurrentIndex(idx) {
            getDataObject().setCurrentIndex(idx);
          }
        }, {
          key: "setParameter",
          value: function setParameter() {
            var _getDataObject;

            (_getDataObject = getDataObject()).setParameter.apply(_getDataObject, arguments);
          }
        }, {
          key: "render",
          value: function render() {
            return React.createElement(WrappedComponent, _extends({}, this.state, {
              onCancelEdit: this.cancelEdit,
              onCurrentIndexChange: this.setCurrentIndex,
              onDeleteRow: this.deleteRow,
              onEndEdit: this.endEdit,
              onFieldChange: this.setFieldValue,
              onFieldsChange: this.setFieldValues,
              onRefreshData: this.refreshData,
              onRefreshRow: this.refreshRow,
              onSetParameter: this.setParameter
            }, this.props));
          }
        }]);

        return connector;
      }(React.Component);

      function getDisplayName() {
        return WrappedComponent.displayName || WrappedComponent.name || "Component";
      }

      connector.displayName = typeof dataObject === "string" ? dataObject : dataObject.getDataSourceId();
      connector.displayName += "(".concat(getDisplayName(), ")");
      return connector;
    };
  }
  var properties = ["onCancelEdit", "onCurrentIndexChange", "onEndEdit", "onDeleteRow", "onFieldChange", "onFieldsChange", "onRefreshData", "onRefreshRow", "onSetParameter", "canDelete", "canUpdate", "canInsert", "currentIndex", "isDirty", "isDeleting", "isLoading", "isSaving", "loadError", "saveFailed"];

  exports.dataObjectConnect = dataObjectConnect;
  exports.properties = properties;

  Object.defineProperty(exports, '__esModule', { value: true });

}));