weapp-wepy-redux/lib/connect/index.js

WePY bindings for Redux

"use strict";

function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = connect;
exports.connectNormal = connectNormal;

var _store = require("../store");

var _helpers = require("../helpers");

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { 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, descriptor.key, descriptor); } }

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

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 _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

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

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

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

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

function connect(states, actions) {
  states = (0, _helpers.mapState)(states || {});
  actions = (0, _helpers.mapActions)(actions || {});
  return function connectComponent(Component) {
    var unSubscribe = null; // 绑定

    var _onLoad = Component.prototype.onLoad;
    var _onUnload = Component.prototype.onUnload;

    var onStateChange = function onStateChange() {
      var _this = this;

      var store = (0, _store.getStore)();
      var hasChanged = false;
      Object.keys(states).forEach(function (k) {
        var newV = states[k].call(_this);

        if (_this[k] !== newV) {
          // 不相等
          _this[k] = newV;
          hasChanged = true;
        }
      });
      hasChanged && this.$apply();
    };

    return /*#__PURE__*/function (_Component) {
      _inherits(_class, _Component);

      var _super = _createSuper(_class);

      function _class() {
        var _this2;

        _classCallCheck(this, _class);

        _this2 = _super.call(this);
        _this2.computed = Object.assign(_this2.computed || {}, states);
        _this2.methods = Object.assign(_this2.methods || {}, actions);
        return _this2;
      }

      _createClass(_class, [{
        key: "onLoad",
        value: function onLoad() {
          var store = (0, _store.getStore)();
          unSubscribe = store.subscribe(onStateChange.bind(this));
          onStateChange.call(this);
          _onLoad && _onLoad.apply(this, arguments);
        }
      }, {
        key: "onUnload",
        value: function onUnload() {
          unSubscribe && unSubscribe();
          unSubscribe = null;
          _onUnload && _onUnload.apply(this, arguments);
        }
      }]);

      return _class;
    }(Component);
  };
}

;

function connectNormal(states, actions, options) {
  states = (0, _helpers.mapState)(states || {});
  actions = (0, _helpers.mapActions)(actions || {}); // return function connectComponent(options) {

  var unSubscribe = null;

  var onStateChange = function onStateChange() {
    var _this3 = this;

    var store = (0, _store.getStore)();
    var hasChanged = false;
    var updateData = {};
    Object.keys(states).forEach(function (k) {
      var newV = states[k].call(_this3);

      if (_this3.data[k] !== newV) {
        // 不相等
        updateData[k] = newV;
        hasChanged = true;
      }
    });
    hasChanged && this.setData(_objectSpread(_objectSpread({}, this.data), updateData));
  };

  options.methods = _objectSpread(_objectSpread({}, options.methods), actions || {});

  if ('onLoad' in options && options.onLoad instanceof Function) {
    var onLoad = options.onLoad;

    options.onLoad = function () {
      var store = (0, _store.getStore)();
      unSubscribe = store.subscribe(onStateChange.bind(this));
      onStateChange.call(this);
      onLoad && onLoad.apply(this, arguments);
    };
  }

  if ('ready' in options && options.ready instanceof Function) {
    console.log('我是测试代码');
    var onReady = options.ready;

    options.ready = function () {
      var store = (0, _store.getStore)();
      unSubscribe = store.subscribe(onStateChange.bind(this));
      onStateChange.call(this);
      onReady && onReady.apply(this, arguments);
    };
  }

  if ('onUnload' in options && options.onUnload instanceof Function) {
    var onUnload = options.onUnload;

    options.onUnload = function () {
      unSubscribe && unSubscribe();
      unSubscribe = null;
      onUnload && onUnload.apply(this, arguments);
    };
  }

  if ('detached' in options && options.detached instanceof Function) {
    var detached = options.detached;

    options.detached = function () {
      unSubscribe && unSubscribe();
      unSubscribe = null;
      detached && detached.apply(this, arguments);
    };
  }

  return options; // };
}

;