@configuratorware/configurator-frontendgui 1.28.6 → 1.29.3

package/App/Reducers/ImageGallery/Reducer.js

@@ -0,0 +1,320 @@
+"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.imageGalleryReducer = imageGalleryReducer;
+exports["default"] = void 0;
+
+var _findIndex = _interopRequireDefault(require("lodash/findIndex"));
+
+var _find = _interopRequireDefault(require("lodash/find"));
+
+var _get = _interopRequireDefault(require("lodash/get"));
+
+var _cloneDeep = _interopRequireDefault(require("lodash/cloneDeep"));
+
+var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
+
+var _Modifiers = require("./Modifiers");
+
+var actionTypes = _interopRequireWildcard(require("./Actions"));
+
+var _Modifiers2 = require("../DesignData/Modifiers");
+
+var _Selectors = require("./Selectors");
+
+var _configuration = require("../../configuration");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+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; }
+
+var updateDerivedImageDataProps = function updateDerivedImageDataProps(imageData) {
+  var _imageData$operations = imageData.operations,
+      operations = _imageData$operations === void 0 ? {} : _imageData$operations;
+  imageData.imageColorsWereEdited = !!operations.vectorizeOriginalColorsMap && !(0, _isEqual["default"])(operations.vectorizeColorsMap, operations.vectorizeOriginalColorsMap);
+  var prevColorPreviewEnabled = imageData.colorPreviewEnabled;
+  imageData.colorPreviewEnabled = imageData.colorPreviewRequired || !!Object.keys(operations.vectorizeOriginalColorsMap || {}).length && (0, _Modifiers2.isOneColorAboveThreshold)(operations.vectorizeColorsMap, operations.vectorizeOriginalColorsMap);
+
+  if (!imageData.colorPreviewEnabled) {
+    imageData.displayColorPreview = false;
+  } else if (!prevColorPreviewEnabled) {
+    imageData.displayColorPreview = (0, _configuration.getConf)('autoPreviewVectorization', true);
+  }
+
+  return imageData;
+};
+
+var initialState = {
+  gallery: [],
+  tags: [],
+  selectedTag: null,
+  selectedTags: [],
+  userImages: [],
+  selectedImage: null,
+  lastErrorCode: null,
+  mode: null
+};
+
+function imageGalleryReducer() {
+  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+  var action = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+  switch (action.type) {
+    case actionTypes.RECEIVE_GALLERY:
+      return _objectSpread(_objectSpread({}, state), {}, {
+        gallery: action.data
+      });
+
+    case actionTypes.RECEIVE_GALLERY_TAGS:
+      return _objectSpread(_objectSpread({}, state), {}, {
+        tags: action.data
+      });
+
+    case actionTypes.SELECT_GALLERY_TAG:
+      return _objectSpread(_objectSpread({}, state), {}, {
+        selectedTag: action.tag
+      });
+
+    case actionTypes.SELECT_GALLERY_TAGS:
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          selectedTags: action.tags
+        });
+      }
+
+    case actionTypes.RECEIVE_IMAGE_UPLOAD_DATA:
+      {
+        var statusCode = (0, _get["default"])(action, 'response.status');
+
+        if (statusCode && statusCode !== 200) {
+          return _objectSpread(_objectSpread({}, state), {}, {
+            lastErrorCode: (0, _get["default"])(action, 'data.code', 'unknown_server_error')
+          });
+        }
+
+        var imageData = _objectSpread(_objectSpread({}, action.imageData), action.data);
+
+        var userImages = state.userImages;
+        var userImage = (0, _find["default"])(userImages, {
+          identifier: imageData.identifier
+        }) || state.selectedImage;
+
+        if (userImage) {
+          imageData.identifier = userImage.identifier;
+
+          if (userImage.originalFileName === imageData.originalFileName) {
+            imageData.displayColorPreview = userImage.displayColorPreview;
+
+            if (!imageData.operations) {
+              imageData.operations = (0, _cloneDeep["default"])(userImage.operations);
+            }
+          }
+        }
+
+        if (!imageData.identifier || action.createCopy) {
+          imageData.identifier = (0, _Modifiers.generateImageId)();
+        }
+
+        updateDerivedImageDataProps(imageData);
+
+        if (action.createCopy && action.immediateCommit) {
+          userImages = [].concat(state.userImages);
+          userImages.push(imageData);
+        }
+
+        return _objectSpread(_objectSpread({}, state), {}, {
+          userImages: userImages,
+          selectedImage: imageData,
+          lastErrorCode: null // clear the error code if succeeded
+
+        });
+      }
+
+    case actionTypes.COMMIT_CHANGES:
+      {
+        var count = action.imageUsageInfo.count,
+            compatibilityInfoHash = action.compatibilityInfoHash;
+        var selectedImage = state.selectedImage,
+            mode = state.mode;
+
+        var _userImages = [].concat(state.userImages);
+
+        var identifier = selectedImage.identifier,
+            fileName = selectedImage.fileName,
+            operations = selectedImage.operations;
+        var currentImage = mode === actionTypes.ImageGalleryModes.add ? (0, _find["default"])(_userImages, {
+          fileName: fileName,
+          operations: operations,
+          compatibilityInfoHash: compatibilityInfoHash
+        }) // try to find an existing one with the same options
+        : count === 1 // if it's the only image, find it by identifier
+        ? (0, _find["default"])(_userImages, {
+          identifier: identifier
+        }) : (0, _find["default"])(_userImages, {
+          identifier: identifier,
+          operations: operations,
+          compatibilityInfoHash: compatibilityInfoHash
+        }) || null;
+
+        if (currentImage) {
+          if (mode === actionTypes.ImageGalleryModes.add) {
+            return _objectSpread(_objectSpread({}, state), {}, {
+              selectedImage: currentImage
+            });
+          } else {
+            Object.assign(currentImage, selectedImage);
+            return _objectSpread(_objectSpread({}, state), {}, {
+              userImages: _userImages
+            });
+          }
+        }
+
+        var newImage = _objectSpread(_objectSpread({}, selectedImage), {}, {
+          compatibilityInfoHash: compatibilityInfoHash,
+          operations: operations || {},
+          identifier: (0, _Modifiers.generateImageId)()
+        });
+
+        _userImages.push(newImage);
+
+        return _objectSpread(_objectSpread({}, state), {}, {
+          userImages: _userImages,
+          selectedImage: newImage
+        });
+      }
+
+    case actionTypes.SET_MODE:
+      {
+        var _mode = action.mode;
+        return _objectSpread(_objectSpread({}, state), {}, {
+          mode: _mode
+        });
+      }
+
+    case actionTypes.SET_SELECTED_IMAGE:
+      {
+        var _imageData = action.imageData,
+            _fileName = action.fileName,
+            _identifier = action.identifier;
+
+        var _selectedImage = _imageData && updateDerivedImageDataProps(_imageData) || _identifier && (0, _find["default"])(state.userImages, {
+          identifier: _identifier
+        }) || _fileName && (0, _find["default"])(state.userImages, {
+          fileName: _fileName
+        }) || null;
+
+        return _objectSpread(_objectSpread({}, state), {}, {
+          selectedImage: _selectedImage
+        });
+      }
+
+    case actionTypes.ADD_IMAGES_FROM_DESIGN_AREA:
+      {
+        return action.data ? _objectSpread(_objectSpread({}, state), {}, {
+          userImages: [].concat(_toConsumableArray(state.userImages), _toConsumableArray(action.data))
+        }) : state;
+      }
+
+    case actionTypes.UPDATE_IMAGE:
+      {
+        var _userImages2 = state.userImages;
+        var designAreas = action.imageUsageInfo.designAreas,
+            imageDataPatch = action.imageDataPatch;
+
+        var _currentImage = state.selectedImage && state.selectedImage.identifier === action.identifier ? state.selectedImage : (0, _find["default"])(_userImages2, {
+          identifier: action.identifier
+        });
+
+        var image = _objectSpread(_objectSpread({}, _currentImage), imageDataPatch); // create new identifier if it's used by multiple areas
+        // avoiding unwanted modification of other occurrences
+
+
+        if (designAreas > 1 && (0, _Selectors.isHardModified)(_currentImage, image)) {
+          image.identifier = (0, _Modifiers.generateImageId)();
+        }
+
+        updateDerivedImageDataProps(image);
+
+        var result = _objectSpread({}, state);
+
+        result.selectedImage = image; // in 'immediate commit' mode the image is directly updated or added
+        // so the extra COMMIT_CHANGES action does not have to be performed
+
+        if (action.immediateCommit) {
+          result.userImages = _toConsumableArray(_userImages2);
+          var idx = (0, _findIndex["default"])(_userImages2, {
+            identifier: image.identifier
+          });
+
+          if (idx !== -1) {
+            result.userImages[idx] = image;
+          } else {
+            result.userImages.push(image);
+          }
+        }
+
+        return result;
+      }
+
+    case actionTypes.ADD_GALLERY_IMAGE_TO_USER_IMAGES:
+      {
+        var imageUrl = action.imageUrl,
+            thumbUrl = action.thumbUrl,
+            _fileName2 = action.fileName,
+            vectorizeColorsMap = action.vectorizeColorsMap,
+            _compatibilityInfoHash = action.compatibilityInfoHash;
+
+        var _image = (0, _Modifiers.createSVGImageData)({
+          imageUrl: imageUrl,
+          thumbUrl: thumbUrl,
+          fileName: _fileName2,
+          operations: {
+            vectorizeColorsMap: vectorizeColorsMap
+          }
+        });
+
+        return _objectSpread(_objectSpread({}, state), {}, {
+          selectedImage: _objectSpread(_objectSpread({}, _image), {}, {
+            compatibilityInfoHash: _compatibilityInfoHash
+          })
+        });
+      }
+
+    case actionTypes.DISMISS_ERROR:
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          lastErrorCode: null
+        });
+      }
+
+    default:
+      return state;
+  }
+}
+
+var _default = imageGalleryReducer;
+exports["default"] = _default;

package/App/Reducers/ImageGallery/Selectors.js

@@ -0,0 +1,206 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isColorPreviewCompatible = exports.isHardModified = exports.showVectorizeImageQuality = exports.isVectorFormat = exports.isColorMappingCompatible = exports.isImageReadyToBeAdded = exports.isImageCompatible = exports.isAddMode = exports.isEditMode = exports.getImageUsageInfo = exports.getUserImagesByDesignArea = exports.getUserImage = exports.isEditableVectorImage = exports.getPreviewUrlFromImageData = void 0;
+
+var _get = _interopRequireDefault(require("lodash/get"));
+
+var _find = _interopRequireDefault(require("lodash/find"));
+
+var _flatten = _interopRequireDefault(require("lodash/flatten"));
+
+var _configuration = require("../../configuration");
+
+var _Selectors = require("../Configurator/Selectors");
+
+var _Reducer = require("../DesignData/Reducer");
+
+var _Actions = require("./Actions");
+
+var _Selectors2 = require("../DesignArea/Selectors");
+
+var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var getPreviewUrlFromImageData = function getPreviewUrlFromImageData(preview) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+  if (/^data:image/.test(preview.url)) {
+    return preview.url;
+  }
+
+  var _options$host = options.host,
+      host = _options$host === void 0 ? (0, _configuration.getConf)('network.host', '') : _options$host;
+  return "".concat(host).concat(preview.url);
+};
+
+exports.getPreviewUrlFromImageData = getPreviewUrlFromImageData;
+
+var isEditableVectorImage = function isEditableVectorImage(preview) {
+  return preview && preview.url && (/.svg$/.test(preview.url) || /^data:image\/svg\+xml/.test(preview.url));
+};
+
+exports.isEditableVectorImage = isEditableVectorImage;
+
+var getUserImage = function getUserImage(state, identifier) {
+  var userImages = (0, _get["default"])(state, 'imageGallery.userImages', []);
+  return (0, _find["default"])(userImages, {
+    identifier: identifier
+  });
+};
+
+exports.getUserImage = getUserImage;
+
+var getUserImagesByDesignArea = function getUserImagesByDesignArea(configuratorState) {
+  var configuration = (0, _Selectors.getConfiguration)(configuratorState);
+  var designData = (0, _get["default"])(configuration, 'designdata');
+
+  if (!designData) {
+    return null;
+  }
+
+  return (0, _flatten["default"])(Object.values(designData) // merge the objects into one array
+  .filter(function (dd) {
+    return !!dd.canvasData;
+  }) // get the areas with existing canvas data
+  .map(function (data) {
+    return data.canvasData.objects;
+  })) // get the objects array from the areas
+  .filter(function (o) {
+    return o.type === 'Image';
+  }) // filter the images
+  .map(function (object) {
+    return object.imageData;
+  }) // get the imageData objects from the images
+  .filter(function (imageData, idx, arr) {
+    return !imageData.isPlaceHolderImage && // placeholders are not needed in the list
+    // uniq by identifier
+    imageData === arr.find(function (_ref) {
+      var identifier = _ref.identifier;
+      return identifier === imageData.identifier;
+    });
+  });
+};
+
+exports.getUserImagesByDesignArea = getUserImagesByDesignArea;
+
+var getImageUsageInfo = function getImageUsageInfo(state, imageIdentifier) {
+  if (!imageIdentifier) {
+    imageIdentifier = (0, _get["default"])(state.imageGallery.selectedImage, 'identifier');
+  }
+
+  if (!imageIdentifier) {
+    return {
+      count: 0,
+      designAreas: 0
+    };
+  }
+
+  return Object.values((0, _Reducer.getDesignData)((0, _Selectors.getConfigurator)(state))).reduce(function (_ref2, _ref3) {
+    var count = _ref2.count,
+        designAreas = _ref2.designAreas;
+    var canvasData = _ref3.canvasData;
+    var countPerArea = canvasData && canvasData.objects ? canvasData.objects.filter(function (_ref4) {
+      var imageData = _ref4.imageData;
+      return imageData && imageData.identifier === imageIdentifier;
+    }).length : 0;
+    return {
+      designAreas: designAreas + (countPerArea ? 1 : 0),
+      count: count + countPerArea
+    };
+  }, {
+    count: 0,
+    designAreas: 0
+  });
+};
+
+exports.getImageUsageInfo = getImageUsageInfo;
+
+var isEditMode = function isEditMode(state) {
+  return (0, _get["default"])(state, 'imageGallery.mode') === _Actions.ImageGalleryModes.edit;
+};
+
+exports.isEditMode = isEditMode;
+
+var isAddMode = function isAddMode(state) {
+  return (0, _get["default"])(state, 'imageGallery.mode') === _Actions.ImageGalleryModes.add;
+};
+
+exports.isAddMode = isAddMode;
+
+var isImageCompatible = function isImageCompatible(state, imageData) {
+  return (0, _Selectors2.areHashesCompatible)(imageData.compatibilityInfoHash, (0, _Selectors2.getCurrentCompatibilityInfoHash)(state));
+};
+
+exports.isImageCompatible = isImageCompatible;
+
+var isImageReadyToBeAdded = function isImageReadyToBeAdded(state, imageData) {
+  return Boolean(imageData && isAddMode(state) && isImageCompatible(state, imageData) && getImageUsageInfo(state, imageData.identifier).count > 0 // make sure it's already added (add it one more time)
+  );
+};
+
+exports.isImageReadyToBeAdded = isImageReadyToBeAdded;
+
+var isColorMappingCompatible = function isColorMappingCompatible(colorPalettes, vectorizeColorsMap) {
+  if (!colorPalettes) {
+    return false;
+  }
+
+  var colors = Object.values(vectorizeColorsMap);
+  return !colors.length || !colors.map(function (_ref5) {
+    var identifier = _ref5.identifier;
+    return JSON.parse(identifier).palette;
+  }).some(function (identifier) {
+    return !(0, _find["default"])(colorPalettes, {
+      identifier: identifier
+    });
+  });
+};
+
+exports.isColorMappingCompatible = isColorMappingCompatible;
+
+var isVectorFormat = function isVectorFormat(extension) {
+  return /^(eps|pdf|ai|svg)$/i.test(extension);
+};
+
+exports.isVectorFormat = isVectorFormat;
+
+var showVectorizeImageQuality = function showVectorizeImageQuality(imageToAnalyse) {
+  var minimumPixelAmount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+
+  if (imageToAnalyse) {
+    var pixelsInTheImage = (0, _get["default"])(imageToAnalyse, 'original.width', 0) * (0, _get["default"])(imageToAnalyse, 'original.height', 0);
+    var hasFormatSVG = (0, _get["default"])(imageToAnalyse, 'original.format', '').toLowerCase() === 'svg';
+    var pixelsOfReference = minimumPixelAmount || (0, _configuration.getConf)('vectorizeImageQuality');
+    return !hasFormatSVG && pixelsInTheImage < pixelsOfReference;
+  }
+
+  return false;
+};
+
+exports.showVectorizeImageQuality = showVectorizeImageQuality;
+
+var isHardModified = function isHardModified(originalImageData, newImageData) {
+  return ['operations', 'compatibilityInfoHash'].some(function (prop) {
+    return !(0, _isEqual["default"])(originalImageData[prop], newImageData[prop]);
+  });
+};
+
+exports.isHardModified = isHardModified;
+
+var isColorPreviewCompatible = function isColorPreviewCompatible(state, image, designProductionMethodIdentifier) {
+  if (!image) {
+    image = state.imageGallery.selectedImage;
+  }
+
+  var designProductionMethod = designProductionMethodIdentifier ? (0, _Selectors2.getDesignProductionMethodByIdentifier)(state, designProductionMethodIdentifier) : (0, _Selectors2.getSelectedDesignProductionMethod)(state);
+  var colorPreviewRequired = (0, _Selectors2.designProductionMethodHasEmbroideryVisualizationEffect)(designProductionMethod);
+  var displayColorPreview = image && (!!image.gallery || !!image.displayColorPreview); // do not let the user to add a raster image if the production method is embroidery
+
+  return !colorPreviewRequired || displayColorPreview || false;
+};
+
+exports.isColorPreviewCompatible = isColorPreviewCompatible;

package/App/Reducers/Reducer.js

@@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = apiReducer;
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _Actions = require("./Actions");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+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; }
+
+var initialState = {
+  sources: {},
+  isFetching: false
+};
+
+function getSourceState(action) {
+  switch (action.type) {
+    case _Actions.REQUEST_DATA:
+      return {
+        isFetching: true,
+        source: action.source
+      };
+
+    case _Actions.POST_DATA:
+      return {
+        isFetching: true,
+        isPosted: true,
+        postData: action.data,
+        source: action.source
+      };
+
+    case _Actions.NETWORK_ERROR:
+      return {
+        isFetching: false,
+        error: action.error,
+        source: action.source
+      };
+
+    case _Actions.REQUEST_ERROR:
+      return {
+        isFetching: false,
+        error: action.error,
+        source: action.source
+      };
+
+    case _Actions.RECEIVE_DATA:
+      return {
+        isFetching: false,
+        data: action.data,
+        source: action.source
+      };
+
+    case _Actions.CANCEL_REQUEST:
+      return {
+        isFetching: false,
+        isCancelled: true,
+        source: action.source
+      };
+  }
+}
+
+function apiReducer() {
+  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+  var action = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+  switch (action.type) {
+    case _Actions.REQUEST_DATA:
+    case _Actions.POST_DATA:
+    case _Actions.NETWORK_ERROR:
+    case _Actions.RECEIVE_DATA:
+    case _Actions.CANCEL_REQUEST:
+    case _Actions.REQUEST_ERROR:
+      {
+        var sourceState = getSourceState(action);
+
+        var sources = _objectSpread({}, state.sources);
+
+        var key = _lodash["default"].isObject(action.source) ? action.source.url : action.source;
+
+        if (sourceState.isFetching) {
+          sources[key] = sourceState;
+        } else {
+          // remove when fetching finished... maybe it saves a bit of memory
+          delete sources[key];
+        }
+
+        return _objectSpread(_objectSpread({}, state), {}, {
+          sources: sources,
+          isFetching: _lodash["default"].reduce(sources, function (result, value) {
+            return result || value.isFetching;
+          }, false)
+        });
+      }
+
+    default:
+      return state;
+  }
+}