@thoughtbot/superglue 0.0.0 → 0.30.0

package/reducers/index.js

@@ -0,0 +1,288 @@
+"use strict";
+
+exports.__esModule = true;
+exports.addFlash = addFlash;
+exports.appendReceivedFragmentsOntoPage = appendReceivedFragmentsOntoPage;
+exports.graftNodeOntoPage = graftNodeOntoPage;
+exports.handleGraft = handleGraft;
+exports.metaReducer = metaReducer;
+exports.pageReducer = pageReducer;
+exports.rootReducer = void 0;
+exports.superglueReducer = superglueReducer;
+
+var _utils = require("../utils");
+
+var _actions = require("../actions");
+
+var _config = require("../config");
+
+function addPlaceholdersToDeferredNodes(existingPage, page) {
+  var _existingPage$defers = existingPage.defers,
+      defers = _existingPage$defers === void 0 ? [] : _existingPage$defers;
+  var prevDefers = defers.map(function (_ref) {
+    var path = _ref.path;
+    var node = (0, _utils.getIn)(existingPage, path);
+    var copy = JSON.stringify(node);
+    return [path, JSON.parse(copy)];
+  });
+  return prevDefers.reduce(function (memo, _ref2) {
+    var path = _ref2[0],
+        node = _ref2[1];
+    return (0, _utils.setIn)(page, path, node);
+  }, page);
+}
+
+function constrainPagesSize(state) {
+  var maxPages = _config.config.maxPages;
+  var allPageKeys = Object.keys(state);
+  var cacheTimesRecentFirst = allPageKeys.map(function (key) {
+    return state[key].savedAt;
+  }).sort(function (a, b) {
+    return b - a;
+  });
+
+  for (var _i = 0, _Array$from = Array.from(allPageKeys); _i < _Array$from.length; _i++) {
+    var key = _Array$from[_i];
+
+    if (state[key].savedAt <= cacheTimesRecentFirst[maxPages - 1]) {
+      delete state[key];
+    }
+  }
+}
+
+function saveResponse(state, pageKey, page) {
+  state = Object.assign({}, state);
+  page = Object.assign({
+    pageKey: pageKey,
+    fragments: []
+  }, page, {
+    savedAt: Date.now()
+  });
+  var existingPage = state[pageKey];
+
+  if (existingPage) {
+    page = addPlaceholdersToDeferredNodes(existingPage, page);
+  }
+
+  constrainPagesSize(state);
+  state[pageKey] = page;
+  return state;
+}
+
+function appendReceivedFragmentsOntoPage(state, pageKey, receivedFragments) {
+  if (!pageKey) {
+    return state;
+  }
+
+  if (receivedFragments.length === 0) {
+    return state;
+  }
+
+  var currentPage = state[pageKey];
+  var _currentPage$fragment = currentPage.fragments,
+      prevFragments = _currentPage$fragment === void 0 ? [] : _currentPage$fragment;
+  var nextFragments = [].concat(prevFragments);
+  var existingKeys = {};
+  prevFragments.forEach(function (frag) {
+    return existingKeys[frag.path] = true;
+  });
+  receivedFragments.forEach(function (frag) {
+    if (!existingKeys[frag.path]) {
+      nextFragments.push(frag);
+    }
+  });
+  var nextPage = Object.assign({}, currentPage, {
+    fragments: nextFragments
+  });
+  var nextState = Object.assign({}, state);
+  nextState[pageKey] = nextPage;
+  return nextState;
+}
+
+function addFlash(state, pageKey, receivedFlash) {
+  var nextState = Object.assign({}, state);
+  var nextPage = Object.assign({}, state[pageKey]);
+  nextPage.flash = Object.assign({}, nextPage.flash, receivedFlash);
+  nextState[pageKey] = nextPage;
+  return nextState;
+}
+
+function graftNodeOntoPage(state, pageKey, node, pathToNode) {
+  if (!node) {
+    console.warn('There was no node returned in the response. Do you have the correct key path in your props_at?');
+    return state;
+  }
+
+  if (!pathToNode || !pageKey) {
+    return state;
+  }
+
+  var fullPathToNode = [pageKey, pathToNode].join('.');
+  return (0, _utils.setIn)(state, fullPathToNode, node);
+}
+
+function handleGraft(state, pageKey, page) {
+  var currentPage = state[pageKey];
+
+  if (!currentPage) {
+    var error = new Error("Superglue was looking for " + pageKey + " in your state, but could not find it in your mapping. Did you forget to pass in a valid pageKey to this.props.remote or this.props.visit?");
+    throw error;
+  }
+
+  var receivedNode = page.data,
+      pathToNode = page.path,
+      _page$fragments = page.fragments,
+      receivedFragments = _page$fragments === void 0 ? [] : _page$fragments,
+      receivedFlash = page.flash;
+  return [function (nextState) {
+    return graftNodeOntoPage(nextState, pageKey, receivedNode, pathToNode);
+  }, function (nextState) {
+    return appendReceivedFragmentsOntoPage(nextState, pageKey, receivedFragments);
+  }, function (nextState) {
+    return addFlash(nextState, pageKey, receivedFlash);
+  }].reduce(function (memo, fn) {
+    return fn(memo);
+  }, state);
+}
+
+function pageReducer(state, action) {
+  if (state === void 0) {
+    state = {};
+  }
+
+  switch (action.type) {
+    case _actions.SAVE_RESPONSE:
+      {
+        var _action$payload = action.payload,
+            pageKey = _action$payload.pageKey,
+            page = _action$payload.page;
+        return saveResponse(state, pageKey, page);
+      }
+
+    case _actions.HANDLE_GRAFT:
+      {
+        var _action$payload2 = action.payload,
+            _pageKey = _action$payload2.pageKey,
+            _page = _action$payload2.page;
+        return handleGraft(state, _pageKey, _page);
+      }
+
+    case _actions.UPDATE_FRAGMENTS:
+      {
+        var changedFragments = action.payload.changedFragments;
+        var nextState = state;
+        Object.entries(state).forEach(function (_ref3) {
+          var pageKey = _ref3[0],
+              page = _ref3[1];
+          page.fragments.forEach(function (fragment) {
+            var type = fragment.type,
+                path = fragment.path;
+            var changedNode = changedFragments[type];
+            var currentNode = (0, _utils.getIn)(nextState, pageKey + "." + path);
+
+            if (type in changedFragments && changedNode !== currentNode) {
+              var nextNode = JSON.parse(JSON.stringify(changedNode));
+              nextState = (0, _utils.setIn)(nextState, pageKey + "." + path, nextNode);
+            }
+          });
+        });
+        return nextState;
+      }
+
+    case _actions.CLEAR_FLASH:
+      {
+        var _pageKey2 = action.payload.pageKey;
+
+        var _nextState = Object.assign({}, state);
+
+        var nextPage = Object.assign({}, state[_pageKey2]);
+        nextPage.flash = {};
+        _nextState[_pageKey2] = nextPage;
+        return _nextState;
+      }
+
+    case _actions.COPY_PAGE:
+      {
+        var _nextState2 = Object.assign({}, state);
+
+        var _action$payload3 = action.payload,
+            from = _action$payload3.from,
+            to = _action$payload3.to;
+        _nextState2[(0, _utils.urlToPageKey)(to)] = JSON.parse(JSON.stringify(_nextState2[from]));
+        return _nextState2;
+      }
+
+    case _actions.REMOVE_PAGE:
+      {
+        var _pageKey3 = action.payload.pageKey;
+
+        var _nextState3 = Object.assign({}, state);
+
+        delete _nextState3[_pageKey3];
+        return _nextState3;
+      }
+
+    default:
+      return state;
+  }
+}
+
+function metaReducer(state, action) {
+  if (state === void 0) {
+    state = {};
+  }
+
+  switch (action.type) {
+    case _actions.HISTORY_CHANGE:
+      {
+        var _action$payload4 = action.payload,
+            pathname = _action$payload4.pathname,
+            search = _action$payload4.search,
+            hash = _action$payload4.hash;
+        var currentPageKey = (0, _utils.urlToPageKey)(pathname + search);
+        return Object.assign({}, state, {
+          currentPageKey: currentPageKey,
+          pathname: pathname,
+          search: search,
+          hash: hash
+        });
+      }
+
+    case _actions.SAVE_RESPONSE:
+      {
+        var _action$payload$page = action.payload.page,
+            csrfToken = _action$payload$page.csrfToken,
+            assets = _action$payload$page.assets;
+        return Object.assign({}, state, {
+          csrfToken: csrfToken,
+          assets: assets
+        });
+      }
+
+    case _actions.SET_CSRF_TOKEN:
+      {
+        var _csrfToken = action.payload.csrfToken;
+        return Object.assign({}, state, {
+          csrfToken: _csrfToken
+        });
+      }
+
+    default:
+      return state;
+  }
+}
+
+function superglueReducer(state, action) {
+  if (state === void 0) {
+    state = {};
+  }
+
+  var meta = metaReducer(state, action);
+  return Object.assign({}, meta);
+}
+
+var rootReducer = {
+  superglue: superglueReducer,
+  pages: pageReducer
+};
+exports.rootReducer = rootReducer;

package/utils/helpers.js

@@ -0,0 +1,36 @@
+"use strict";
+
+exports.__esModule = true;
+exports.argsForHistory = argsForHistory;
+exports.extractNodeAndPath = extractNodeAndPath;
+exports.isGraft = isGraft;
+
+var _url = require("./url");
+
+function isGraft(page) {
+  return page.action === 'graft';
+}
+
+function extractNodeAndPath(page) {
+  var node = page.data,
+      action = page.action,
+      pathToNode = page.path;
+
+  if (action === 'graft') {
+    return {
+      node: node,
+      pathToNode: pathToNode
+    };
+  } else {
+    var errMsg = 'Expected page to be a graft response rendered from node filtering.';
+    throw new Error(errMsg);
+  }
+}
+
+function argsForHistory(path) {
+  var pageKey = (0, _url.urlToPageKey)(path);
+  return [path, {
+    superglue: true,
+    pageKey: pageKey
+  }];
+}

package/utils/immutability.js

@@ -0,0 +1,176 @@
+"use strict";
+
+exports.__esModule = true;
+exports.KeyPathError = void 0;
+exports.getIn = getIn;
+exports.setIn = setIn;
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+
+function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
+
+function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+
+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 _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+// These were taken from Scour.js
+// Then, modified to respect the id=0 keypath
+var isSearchable = /^[\da-zA-Z\-_=.]+$/;
+
+var KeyPathError = /*#__PURE__*/function (_Error) {
+  _inheritsLoose(KeyPathError, _Error);
+
+  function KeyPathError(message) {
+    var _this;
+
+    _this = _Error.call(this, message) || this;
+    _this.name = 'KeyPathError';
+    return _this;
+  }
+
+  return KeyPathError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+exports.KeyPathError = KeyPathError;
+
+function getIn(obj, path) {
+  var keyPath = normalizeKeyPath(path);
+  var result = obj;
+
+  for (var i = 0; i < keyPath.length; i++) {
+    var key = keyPath[i];
+
+    if (!result) {
+      break;
+    }
+
+    result = atKey(result, key);
+  }
+
+  return result;
+}
+
+function clone(object) {
+  return Array.isArray(object) ? [].slice.call(object) : Object.assign({}, object);
+}
+
+function getKey(node, key) {
+  if (Array.isArray(node) && isNaN(key)) {
+    var key_parts = Array.from(key.split('='));
+    var attr = key_parts[0];
+    var id = key_parts[1];
+    var i, child;
+
+    if (!id) {
+      return key;
+    }
+
+    for (i = 0; i < node.length; i++) {
+      child = node[i];
+
+      if (child[attr].toString() === id) {
+        break;
+      }
+    }
+
+    return i;
+  } else {
+    return key;
+  }
+}
+
+function isArray(ary) {
+  return Array.isArray(ary);
+}
+
+function isObject(obj) {
+  return !isArray(obj) && obj === Object(obj);
+}
+
+function atKey(node, key) {
+  var id, attr;
+
+  if (isSearchable.test(key)) {
+    // eslint-disable-next-line
+    ;
+
+    var _Array$from = Array.from(key.split('='));
+
+    attr = _Array$from[0];
+    id = _Array$from[1];
+  }
+
+  if (!isArray(node) && !isObject(node)) {
+    throw new KeyPathError("Expected to traverse an Array or Obj, got " + JSON.stringify(node));
+  }
+
+  if (isObject(node) && id) {
+    throw new KeyPathError("Expected to find an Array when using the key: " + key);
+  }
+
+  if (isObject(node) && !Object.prototype.hasOwnProperty.call(node, key)) {
+    throw new KeyPathError("Expected to find key: " + key + " in object " + JSON.stringify(node));
+  }
+
+  if (Array.isArray(node) && id) {
+    var child;
+
+    for (var i = 0; i < node.length; i++) {
+      child = node[i];
+
+      if (child[attr].toString() === id) {
+        break;
+      }
+    }
+
+    if (child[attr].toString() === id) {
+      return child;
+    } else {
+      return undefined;
+    }
+  } else {
+    return node[key];
+  }
+}
+
+function normalizeKeyPath(path) {
+  if (typeof path === 'string') {
+    path = path.replace(/ /g, '');
+
+    if (path === '') {
+      return [];
+    }
+
+    return path.split('.');
+  } else {
+    return path;
+  }
+}
+
+function setIn(object, keypath, value) {
+  keypath = normalizeKeyPath(keypath);
+  var results = {};
+  var parents = {};
+  var i;
+  parents[0] = object;
+
+  for (i = 0; i < keypath.length; i++) {
+    parents[i + 1] = atKey(parents[i], keypath[i]);
+  }
+
+  results[keypath.length] = value;
+
+  for (i = keypath.length - 1; i >= 0; i--) {
+    results[i] = clone(parents[i]);
+    var key = getKey(results[i], keypath[i]);
+    results[i][key] = results[i + 1];
+  }
+
+  return results[0];
+}

package/utils/index.js

@@ -0,0 +1,59 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _helpers = require("./helpers");
+
+Object.keys(_helpers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _helpers[key]) return;
+  exports[key] = _helpers[key];
+});
+
+var _immutability = require("./immutability");
+
+Object.keys(_immutability).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _immutability[key]) return;
+  exports[key] = _immutability[key];
+});
+
+var _react = require("./react");
+
+Object.keys(_react).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _react[key]) return;
+  exports[key] = _react[key];
+});
+
+var _request = require("./request");
+
+Object.keys(_request).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _request[key]) return;
+  exports[key] = _request[key];
+});
+
+var _ujs = require("./ujs");
+
+Object.keys(_ujs).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _ujs[key]) return;
+  exports[key] = _ujs[key];
+});
+
+var _url = require("./url");
+
+Object.keys(_url).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _url[key]) return;
+  exports[key] = _url[key];
+});
+
+var _window = require("./window");
+
+Object.keys(_window).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _window[key]) return;
+  exports[key] = _window[key];
+});

package/utils/react.js

@@ -0,0 +1,52 @@
+"use strict";
+
+exports.__esModule = true;
+exports.mapDispatchToPropsIncludingVisitAndRemote = exports.mapDispatchToProps = void 0;
+exports.mapStateToProps = mapStateToProps;
+
+var _action_creators = require("../action_creators");
+
+var _url = require("./url");
+
+function mapStateToProps(state, ownProps) {
+  if (state === void 0) {
+    state = {
+      pages: {},
+      superglue: {}
+    };
+  }
+
+  var pageKey = ownProps.pageKey;
+  var params = ownProps;
+  var csrfToken = state.superglue.csrfToken;
+  pageKey = (0, _url.urlToPageKey)(pageKey);
+
+  var _ref = state.pages[pageKey] || {
+    data: {},
+    flash: {},
+    fragments: []
+  },
+      data = _ref.data,
+      flash = _ref.flash,
+      fragments = _ref.fragments;
+
+  return Object.assign({}, data, params, {
+    pageKey: pageKey,
+    csrfToken: csrfToken,
+    flash: flash,
+    fragments: fragments
+  });
+}
+
+var mapDispatchToProps = {
+  saveAndProcessPage: _action_creators.saveAndProcessPage,
+  copyPage: _action_creators.copyPage
+};
+exports.mapDispatchToProps = mapDispatchToProps;
+var mapDispatchToPropsIncludingVisitAndRemote = {
+  visit: _action_creators.visit,
+  remote: _action_creators.remote,
+  saveAndProcessPage: _action_creators.saveAndProcessPage,
+  copyPage: _action_creators.copyPage
+};
+exports.mapDispatchToPropsIncludingVisitAndRemote = mapDispatchToPropsIncludingVisitAndRemote;