dash-renderer/lib/actions/patch.js

render dash components in react

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.PatchBuilder = void 0;
exports.handlePatch = handlePatch;
exports.isPatch = isPatch;
exports.parsePatchProps = parsePatchProps;
var _ramda = require("ramda");
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 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 _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : 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); }
function isPatch(obj) {
  return (0, _ramda.has)('__dash_patch_update', obj);
}
function getLocationIndex(value, previous) {
  if ((0, _ramda.is)(Number, value) && value < 0) {
    return previous.length + value;
  }
  return value;
}
function getLocationPath(location, obj) {
  var current = [];
  for (var i = 0; i < location.length; i++) {
    var value = getLocationIndex(location[i], (0, _ramda.path)(current, obj));
    current.push(value);
  }
  return current;
}
var PatchBuilder = exports.PatchBuilder = /*#__PURE__*/function () {
  function PatchBuilder() {
    _classCallCheck(this, PatchBuilder);
    _defineProperty(this, "operations", []);
  }
  return _createClass(PatchBuilder, [{
    key: "assign",
    value: function assign(location, value) {
      this.operations.push({
        operation: 'Assign',
        location,
        params: {
          value
        }
      });
      return this;
    }
  }, {
    key: "merge",
    value: function merge(location, value) {
      this.operations.push({
        operation: 'Merge',
        location,
        params: {
          value
        }
      });
      return this;
    }
  }, {
    key: "extend",
    value: function extend(location, value) {
      this.operations.push({
        operation: 'Extend',
        location,
        params: {
          value
        }
      });
      return this;
    }
  }, {
    key: "delete",
    value: function _delete(location) {
      this.operations.push({
        operation: 'Delete',
        location,
        params: {}
      });
      return this;
    }
  }, {
    key: "insert",
    value: function insert(location, index, value) {
      this.operations.push({
        operation: 'Insert',
        location,
        params: {
          index,
          value
        }
      });
      return this;
    }
  }, {
    key: "append",
    value: function append(location, value) {
      this.operations.push({
        operation: 'Append',
        location,
        params: {
          value
        }
      });
      return this;
    }
  }, {
    key: "prepend",
    value: function prepend(location, value) {
      this.operations.push({
        operation: 'Prepend',
        location,
        params: {
          value
        }
      });
      return this;
    }
  }, {
    key: "add",
    value: function add(location, value) {
      this.operations.push({
        operation: 'Add',
        location,
        params: {
          value
        }
      });
      return this;
    }
  }, {
    key: "sub",
    value: function sub(location, value) {
      this.operations.push({
        operation: 'Sub',
        location,
        params: {
          value
        }
      });
      return this;
    }
  }, {
    key: "mul",
    value: function mul(location, value) {
      this.operations.push({
        operation: 'Mul',
        location,
        params: {
          value
        }
      });
      return this;
    }
  }, {
    key: "div",
    value: function div(location, value) {
      this.operations.push({
        operation: 'Div',
        location,
        params: {
          value
        }
      });
      return this;
    }
  }, {
    key: "clear",
    value: function clear(location) {
      this.operations.push({
        operation: 'Clear',
        location,
        params: {}
      });
      return this;
    }
  }, {
    key: "reverse",
    value: function reverse(location) {
      this.operations.push({
        operation: 'Reverse',
        location,
        params: {}
      });
      return this;
    }
  }, {
    key: "remove",
    value: function remove(location, value) {
      this.operations.push({
        operation: 'Remove',
        location,
        params: {
          value
        }
      });
      return this;
    }
  }, {
    key: "build",
    value: function build() {
      return {
        __dash_patch_update: '__dash_patch_update',
        operations: this.operations
      };
    }
  }]);
}();
var patchHandlers = {
  Assign: function Assign(previous, patchOperation) {
    var params = patchOperation.params,
      location = patchOperation.location;
    return (0, _ramda.assocPath)(location, params.value, previous);
  },
  Merge: function Merge(previous, patchOperation) {
    var prev = (0, _ramda.path)(patchOperation.location, previous);
    return (0, _ramda.assocPath)(patchOperation.location, _objectSpread(_objectSpread({}, prev), patchOperation.params.value), previous);
  },
  Extend: function Extend(previous, patchOperation) {
    var prev = (0, _ramda.path)(patchOperation.location, previous);
    return (0, _ramda.assocPath)(patchOperation.location, (0, _ramda.concat)(prev, patchOperation.params.value), previous);
  },
  Delete: function Delete(previous, patchOperation) {
    return (0, _ramda.dissocPath)(patchOperation.location, previous);
  },
  Insert: function Insert(previous, patchOperation) {
    var prev = (0, _ramda.path)(patchOperation.location, previous);
    return (0, _ramda.assocPath)(patchOperation.location, (0, _ramda.insert)(getLocationIndex(patchOperation.params.index, prev), patchOperation.params.value, prev), previous);
  },
  Append: function Append(previous, patchOperation) {
    var prev = (0, _ramda.path)(patchOperation.location, previous);
    return (0, _ramda.assocPath)(patchOperation.location, (0, _ramda.append)(patchOperation.params.value, prev), previous);
  },
  Prepend: function Prepend(previous, patchOperation) {
    var prev = (0, _ramda.path)(patchOperation.location, previous);
    return (0, _ramda.assocPath)(patchOperation.location, (0, _ramda.prepend)(patchOperation.params.value, prev), previous);
  },
  Add: function Add(previous, patchOperation) {
    var prev = (0, _ramda.path)(patchOperation.location, previous);
    return (0, _ramda.assocPath)(patchOperation.location, prev + patchOperation.params.value, previous);
  },
  Sub: function Sub(previous, patchOperation) {
    var prev = (0, _ramda.path)(patchOperation.location, previous);
    return (0, _ramda.assocPath)(patchOperation.location, prev - patchOperation.params.value, previous);
  },
  Mul: function Mul(previous, patchOperation) {
    var prev = (0, _ramda.path)(patchOperation.location, previous);
    return (0, _ramda.assocPath)(patchOperation.location, prev * patchOperation.params.value, previous);
  },
  Div: function Div(previous, patchOperation) {
    var prev = (0, _ramda.path)(patchOperation.location, previous);
    return (0, _ramda.assocPath)(patchOperation.location, prev / patchOperation.params.value, previous);
  },
  Clear: function Clear(previous, patchOperation) {
    var prev = (0, _ramda.path)(patchOperation.location, previous);
    return (0, _ramda.assocPath)(patchOperation.location, (0, _ramda.empty)(prev), previous);
  },
  Reverse: function Reverse(previous, patchOperation) {
    var prev = (0, _ramda.path)(patchOperation.location, previous);
    return (0, _ramda.assocPath)(patchOperation.location, (0, _ramda.reverse)(prev), previous);
  },
  Remove: function Remove(previous, patchOperation) {
    var prev = (0, _ramda.path)(patchOperation.location, previous);
    return (0, _ramda.assocPath)(patchOperation.location, prev.filter(function (item) {
      return !(0, _ramda.equals)(item, patchOperation.params.value);
    }), previous);
  }
};
function handlePatch(previousValue, patchValue) {
  var reducedValue = previousValue;
  for (var i = 0; i < patchValue.operations.length; i++) {
    var patch = patchValue.operations[i];
    patch.location = getLocationPath(patch.location, reducedValue);
    var handler = patchHandlers[patch.operation];
    if (!handler) {
      throw new Error("Invalid Operation ".concat(patch.operation));
    }
    reducedValue = handler(reducedValue, patch);
  }
  return reducedValue;
}
function parsePatchProps(props, previousProps) {
  if (!(0, _ramda.is)(Object, props)) {
    return props;
  }
  var patchedProps = {};
  for (var _i = 0, _Object$keys = Object.keys(props); _i < _Object$keys.length; _i++) {
    var key = _Object$keys[_i];
    var val = props[key];
    if (isPatch(val)) {
      var previousValue = previousProps[key];
      if (previousValue === undefined) {
        throw new Error('Cannot patch undefined');
      }
      patchedProps[key] = handlePatch(previousValue, val);
    } else {
      patchedProps[key] = val;
    }
  }
  return patchedProps;
}