@olea-bps/base 1.0.0

package/libraries/redux-offline/lib/defaults/index.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _persist = _interopRequireDefault(require("./persist"));
+var _detectNetwork = _interopRequireDefault(require("./detectNetwork"));
+var _effect = _interopRequireDefault(require("./effect"));
+var _retry = _interopRequireDefault(require("./retry"));
+var _discard = _interopRequireDefault(require("./discard"));
+var _defaultCommit = _interopRequireDefault(require("./defaultCommit"));
+var _defaultRollback = _interopRequireDefault(require("./defaultRollback"));
+var _persistAutoRehydrate = _interopRequireDefault(require("./persistAutoRehydrate"));
+var _offlineStateLens = _interopRequireDefault(require("./offlineStateLens"));
+var _queue = _interopRequireDefault(require("./queue"));
+var _default = exports.default = {
+  rehydrate: true,
+  // backward compatibility, TODO remove in the next breaking change version
+  persist: _persist.default,
+  detectNetwork: _detectNetwork.default,
+  effect: _effect.default,
+  retry: _retry.default,
+  discard: _discard.default,
+  defaultCommit: _defaultCommit.default,
+  defaultRollback: _defaultRollback.default,
+  persistAutoRehydrate: _persistAutoRehydrate.default,
+  offlineStateLens: _offlineStateLens.default,
+  queue: _queue.default,
+  returnPromises: false
+};

package/libraries/redux-offline/lib/defaults/offlineStateLens.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _excluded = ["offline"];
+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) { (0, _defineProperty2.default)(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; }
+var _default = exports.default = function _default(state) {
+  var offline = state.offline,
+    rest = (0, _objectWithoutProperties2.default)(state, _excluded);
+  return {
+    get: offline,
+    set: function set(offlineState) {
+      return typeof offlineState === 'undefined' ? rest : _objectSpread({
+        offline: offlineState
+      }, rest);
+    }
+  };
+};

package/libraries/redux-offline/lib/defaults/persist.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reduxPersist = require("redux-persist");
+// flow
+var _default = exports.default = _reduxPersist.persistStore;

package/libraries/redux-offline/lib/defaults/persist.native.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reduxPersist = require("redux-persist");
+var _asyncStorage = _interopRequireDefault(require("@react-native-async-storage/async-storage"));
+// $FlowIgnore
+// $FlowIgnore
+var _default = exports.default = function _default(store, options, callback) {
+  return (
+    // $FlowFixMe
+    (0, _reduxPersist.persistStore)(store, callback)
+  );
+};

package/libraries/redux-offline/lib/defaults/persistAutoRehydrate.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reduxPersist = require("redux-persist");
+var _default = exports.default = _reduxPersist.autoRehydrate;

package/libraries/redux-offline/lib/defaults/queue.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _toArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toArray"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+/* eslint-disable no-unused-vars */
+
+function enqueue(array, item, context) {
+  return [].concat((0, _toConsumableArray2.default)(array), [item]);
+}
+function dequeue(array, item, context) {
+  var _array = (0, _toArray2.default)(array),
+    rest = _array.slice(1);
+  return rest;
+}
+function peek(array, item, context) {
+  return array[0];
+}
+var _default = exports.default = {
+  enqueue: enqueue,
+  dequeue: dequeue,
+  peek: peek
+};

package/libraries/redux-offline/lib/defaults/retry.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var decaySchedule = [1000,
+// After 1 seconds
+1000 * 5,
+// After 5 seconds
+1000 * 15,
+// After 15 seconds
+1000 * 30,
+// After 30 seconds
+1000 * 60,
+// After 1 minute
+1000 * 60 * 3,
+// After 3 minutes
+1000 * 60 * 5,
+// After 5 minutes
+1000 * 60 * 10,
+// After 10 minutes
+1000 * 60 * 30,
+// After 30 minutes
+1000 * 60 * 60 // After 1 hour
+];
+var _default = exports.default = function _default(action, retries) {
+  return decaySchedule[retries] || null;
+};

package/libraries/redux-offline/lib/index.js

@@ -0,0 +1,115 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.offline = exports.createOffline = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _redux = require("redux");
+var _middleware = require("./middleware");
+var _updater = require("./updater");
+var _config = require("./config");
+var _actions = require("./actions");
+var _offlineActionTracker = _interopRequireDefault(require("./offlineActionTracker"));
+/* global $Shape */
+// @TODO: Take createStore as config?
+var warnIfNotReduxAction = function warnIfNotReduxAction(config, key) {
+  var maybeAction = config[key];
+  var isNotReduxAction = maybeAction === null || (0, _typeof2.default)(maybeAction) !== 'object' || typeof maybeAction.type !== 'string' || maybeAction.type === '';
+  if (isNotReduxAction && console.warn) {
+    var msg = "".concat(key, " must be a proper redux action, ") + "i.e. it must be an object and have a non-empty string type. " + "Instead you provided: ".concat(JSON.stringify(maybeAction, null, 2));
+    console.warn(msg);
+  }
+};
+var offline = exports.offline = function offline() {
+  var userConfig = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return function (createStore) {
+    return function (reducer, preloadedState) {
+      var enhancer = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function (x) {
+        return x;
+      };
+      var config = (0, _config.applyDefaults)(userConfig);
+      warnIfNotReduxAction(config, 'defaultCommit');
+      warnIfNotReduxAction(config, 'defaultRollback');
+
+      // toggle experimental returned promises
+      config.offlineActionTracker = config.returnPromises ? _offlineActionTracker.default.withPromises : _offlineActionTracker.default.withoutPromises;
+      delete config.returnPromises;
+
+      // wraps userland reducer with a top-level
+      // reducer that handles offline state updating
+      var offlineReducer = (0, _updater.enhanceReducer)(reducer, config);
+
+      // $FlowFixMe
+      var offlineMiddleware = (0, _redux.applyMiddleware)((0, _middleware.createOfflineMiddleware)(config));
+
+      // create autoRehydrate enhancer if required
+      var offlineEnhancer = config.persist && config.rehydrate && config.persistAutoRehydrate ? (0, _redux.compose)(offlineMiddleware, config.persistAutoRehydrate()) : offlineMiddleware;
+
+      // create store
+      var store = offlineEnhancer(createStore)(offlineReducer, preloadedState, enhancer);
+      var baseReplaceReducer = store.replaceReducer.bind(store);
+      // $FlowFixMe
+      store.replaceReducer = function replaceReducer(nextReducer) {
+        return baseReplaceReducer((0, _updater.enhanceReducer)(nextReducer, config));
+      };
+
+      // launch store persistor
+      if (config.persist) {
+        config.persist(store, config.persistOptions, config.persistCallback);
+      }
+
+      // launch network detector
+      if (config.detectNetwork) {
+        config.detectNetwork(function (online) {
+          store.dispatch((0, _actions.networkStatusChanged)(online));
+        });
+      }
+      return store;
+    };
+  };
+};
+var createOffline = exports.createOffline = function createOffline() {
+  var userConfig = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var config = (0, _config.applyDefaults)(userConfig);
+
+  // toggle experimental returned promises
+  config.offlineActionTracker = config.returnPromises ? _offlineActionTracker.default.withPromises : _offlineActionTracker.default.withoutPromises;
+  delete config.returnPromises;
+  warnIfNotReduxAction(config, 'defaultCommit');
+  warnIfNotReduxAction(config, 'defaultRollback');
+  var enhanceStore = function enhanceStore(next) {
+    return function (reducer, preloadedState, enhancer) {
+      // create autoRehydrate enhancer if required
+      var createStore = config.persist && config.rehydrate && config.persistAutoRehydrate ? config.persistAutoRehydrate()(next) : next;
+
+      // create store
+      var store = createStore(reducer, preloadedState, enhancer);
+      var baseReplaceReducer = store.replaceReducer.bind(store);
+      store.replaceReducer = function replaceReducer(nextReducer) {
+        return baseReplaceReducer((0, _updater.enhanceReducer)(nextReducer, config));
+      };
+
+      // launch store persistor
+      if (config.persist) {
+        config.persist(store, config.persistOptions, config.persistCallback);
+      }
+
+      // launch network detector
+      if (config.detectNetwork) {
+        config.detectNetwork(function (online) {
+          store.dispatch((0, _actions.networkStatusChanged)(online));
+        });
+      }
+      return store;
+    };
+  };
+  return {
+    middleware: (0, _middleware.createOfflineMiddleware)(config),
+    enhanceReducer: function enhanceReducer(reducer) {
+      return (0, _updater.enhanceReducer)(reducer, config);
+    },
+    enhanceStore: enhanceStore
+  };
+};

package/libraries/redux-offline/lib/middleware.js

@@ -0,0 +1,56 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createOfflineMiddleware = void 0;
+var _constants = require("./constants");
+var _actions = require("./actions");
+var _send = _interopRequireDefault(require("./send"));
+var after = function after() {
+  var timeout = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  return new Promise(function (resolve) {
+    return setTimeout(resolve, timeout);
+  });
+};
+var createOfflineMiddleware = exports.createOfflineMiddleware = function createOfflineMiddleware(config) {
+  return function (store) {
+    return function (next) {
+      return function (action) {
+        // allow other middleware to do their things
+        var result = next(action);
+        var promise;
+
+        // find any actions to send, if any
+        var state = store.getState();
+        var offline = config.offlineStateLens(state).get;
+        var context = {
+          offline: offline
+        };
+        var offlineAction = config.queue.peek(offline.outbox, action, context);
+
+        // create promise to return on enqueue offline action
+        if (action.meta && action.meta.offline) {
+          var registerAction = config.offlineActionTracker.registerAction;
+          promise = registerAction(offline.lastTransaction);
+        }
+
+        // if there are any actions in the queue that we are not
+        // yet processing, send those actions
+        if (offlineAction && !offline.busy && !offline.retryScheduled && offline.online) {
+          (0, _send.default)(offlineAction, store.dispatch, config, offline.retryCount);
+        }
+        if (action.type === _constants.OFFLINE_SCHEDULE_RETRY) {
+          after(action.payload.delay).then(function () {
+            store.dispatch((0, _actions.completeRetry)(offlineAction));
+          });
+        }
+        if (action.type === _constants.OFFLINE_SEND && offlineAction && !offline.busy) {
+          (0, _send.default)(offlineAction, store.dispatch, config, offline.retryCount);
+        }
+        return promise || result;
+      };
+    };
+  };
+};

package/libraries/redux-offline/lib/offlineActionTracker.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var subscriptions = {};
+function registerAction(transaction) {
+  return new Promise(function (resolve, reject) {
+    subscriptions[transaction] = {
+      resolve: resolve,
+      reject: reject
+    };
+  });
+}
+function resolveAction(transaction, value) {
+  var subscription = subscriptions[transaction];
+  if (subscription) {
+    subscription.resolve(value);
+    delete subscriptions[transaction];
+  }
+}
+function rejectAction(transaction, error) {
+  var subscription = subscriptions[transaction];
+  if (subscription) {
+    subscription.reject(error);
+    delete subscriptions[transaction];
+  }
+}
+var withPromises = {
+  registerAction: registerAction,
+  resolveAction: resolveAction,
+  rejectAction: rejectAction
+};
+var withoutPromises = {
+  registerAction: function registerAction() {},
+  resolveAction: function resolveAction() {},
+  rejectAction: function rejectAction() {}
+};
+var _default = exports.default = {
+  withPromises: withPromises,
+  withoutPromises: withoutPromises
+};

package/libraries/redux-offline/lib/send.js

@@ -0,0 +1,112 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _actions = require("./actions");
+var _constants = require("./constants");
+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) { (0, _defineProperty2.default)(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; }
+var complete = function complete(action, result, offlineAction, config) {
+  var _config$offlineAction = config.offlineActionTracker,
+    resolveAction = _config$offlineAction.resolveAction,
+    rejectAction = _config$offlineAction.rejectAction;
+  if (result.success) {
+    resolveAction(offlineAction.meta.transaction, result.payload);
+  } else if (result.payload) {
+    rejectAction(offlineAction.meta.transaction, result.payload);
+  }
+  return _objectSpread(_objectSpread({}, action), {}, {
+    payload: result.payload,
+    meta: _objectSpread(_objectSpread({}, action.meta), {}, {
+      success: result.success,
+      completed: true
+    })
+  });
+};
+var handleJsError = function handleJsError(error) {
+  return {
+    type: _constants.JS_ERROR,
+    meta: {
+      error: error,
+      success: false,
+      completed: true
+    }
+  };
+};
+var send = function send(action, dispatch, config) {
+  var retries = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  var metadata = action.meta.offline;
+  dispatch((0, _actions.busy)(true));
+  return config.effect(metadata.effect, action).then(function (result) {
+    var commitAction = metadata.commit || _objectSpread(_objectSpread({}, config.defaultCommit), {}, {
+      meta: _objectSpread(_objectSpread({}, config.defaultCommit.meta), {}, {
+        offlineAction: action
+      })
+    });
+    try {
+      return dispatch(complete(commitAction, {
+        success: true,
+        payload: result
+      }, action, config));
+    } catch (error) {
+      return dispatch(handleJsError(error));
+    }
+  }).catch(/*#__PURE__*/function () {
+    var _ref = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee(error) {
+      var rollbackAction, mustDiscard, delay, _t;
+      return _regenerator.default.wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            rollbackAction = metadata.rollback || _objectSpread(_objectSpread({}, config.defaultRollback), {}, {
+              meta: _objectSpread(_objectSpread({}, config.defaultRollback.meta), {}, {
+                offlineAction: action
+              })
+            }); // discard
+            mustDiscard = true;
+            _context.prev = 1;
+            _context.next = 2;
+            return config.discard(error, action, retries);
+          case 2:
+            mustDiscard = _context.sent;
+            _context.next = 4;
+            break;
+          case 3:
+            _context.prev = 3;
+            _t = _context["catch"](1);
+            console.warn(_t);
+          case 4:
+            if (mustDiscard) {
+              _context.next = 5;
+              break;
+            }
+            delay = config.retry(action, retries);
+            if (!(delay != null)) {
+              _context.next = 5;
+              break;
+            }
+            return _context.abrupt("return", dispatch((0, _actions.scheduleRetry)(delay)));
+          case 5:
+            return _context.abrupt("return", dispatch(complete(rollbackAction, {
+              success: false,
+              payload: error
+            }, action, config)));
+          case 6:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[1, 3]]);
+    }));
+    return function (_x) {
+      return _ref.apply(this, arguments);
+    };
+  }()).finally(function () {
+    return dispatch((0, _actions.busy)(false));
+  });
+};
+var _default = exports.default = send;

package/libraries/redux-offline/lib/types.js

@@ -0,0 +1,3 @@
+"use strict";
+
+var _constants = require("./constants");

package/libraries/redux-offline/lib/updater.js

@@ -0,0 +1,111 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initialState = exports.enhanceReducer = exports.buildOfflineUpdater = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _constants = require("./constants");
+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) { (0, _defineProperty2.default)(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; } /* global $Shape */
+var initialState = exports.initialState = {
+  busy: false,
+  lastTransaction: 0,
+  online: false,
+  outbox: [],
+  retryCount: 0,
+  retryScheduled: false,
+  netInfo: {
+    isConnectionExpensive: null,
+    reach: 'NONE'
+  }
+};
+var buildOfflineUpdater = exports.buildOfflineUpdater = function buildOfflineUpdater(dequeue, enqueue) {
+  return function offlineUpdater() {
+    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+    var action = arguments.length > 1 ? arguments[1] : undefined;
+    // Update online/offline status
+    if (action.type === _constants.OFFLINE_STATUS_CHANGED && !action.meta) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        online: action.payload.online,
+        netInfo: action.payload.netInfo
+      });
+    }
+    if (action.type === _constants.PERSIST_REHYDRATE && action.payload) {
+      return _objectSpread(_objectSpread(_objectSpread({}, state), action.payload.offline || {}), {}, {
+        online: state.online,
+        netInfo: state.netInfo,
+        retryScheduled: initialState.retryScheduled,
+        retryCount: initialState.retryCount,
+        busy: initialState.busy
+      });
+    }
+    if (action.type === _constants.OFFLINE_SCHEDULE_RETRY) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        retryScheduled: true,
+        retryCount: state.retryCount + 1
+      });
+    }
+    if (action.type === _constants.OFFLINE_COMPLETE_RETRY) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        retryScheduled: false
+      });
+    }
+    if (action.type === _constants.OFFLINE_BUSY && !action.meta && action.payload && typeof action.payload.busy === 'boolean') {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        busy: action.payload.busy
+      });
+    }
+
+    // Add offline actions to queue
+    if (action.meta && action.meta.offline) {
+      var transaction = state.lastTransaction + 1;
+      var stamped = _objectSpread(_objectSpread({}, action), {}, {
+        meta: _objectSpread(_objectSpread({}, action.meta), {}, {
+          transaction: transaction
+        })
+      });
+      var offline = state;
+      return _objectSpread(_objectSpread({}, state), {}, {
+        lastTransaction: transaction,
+        outbox: enqueue(offline.outbox, stamped, {
+          offline: offline
+        })
+      });
+    }
+
+    // Remove completed actions from queue (success or fail)
+    if (action.meta && action.meta.completed === true) {
+      var _offline = state;
+      return _objectSpread(_objectSpread({}, state), {}, {
+        outbox: dequeue(_offline.outbox, action, {
+          offline: _offline
+        }),
+        retryCount: 0
+      });
+    }
+    if (action.type === _constants.RESET_STATE) {
+      return _objectSpread(_objectSpread({}, initialState), {}, {
+        online: state.online,
+        netInfo: state.netInfo
+      });
+    }
+    return state;
+  };
+};
+var enhanceReducer = exports.enhanceReducer = function enhanceReducer(reducer, config) {
+  var _config$queue = config.queue,
+    dequeue = _config$queue.dequeue,
+    enqueue = _config$queue.enqueue;
+  var offlineUpdater = buildOfflineUpdater(dequeue, enqueue);
+  return function (state, action) {
+    var offlineState;
+    var restState;
+    if (typeof state !== 'undefined') {
+      offlineState = config.offlineStateLens(state).get;
+      restState = config.offlineStateLens(state).set();
+    }
+    return config.offlineStateLens(reducer(restState, action)).set(offlineUpdater(offlineState, action));
+  };
+};

package/libraries/redux-offline/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@olea-bps/redux-offline",
+  "version": "1.0.1",
+  "description": "Redux Offline-First Architecture forked from https://github.com/redux-offline/redux-offline",
+  "main": "lib/index.js",
+  "scripts": {
+    "build": "rm -rf lib && babel src --out-dir lib --ignore '**/__tests__/**'",
+    "flow:start": "flow server",
+    "flow:stop": "flow stop",
+    "flow": "flow; test $? -eq 0 -o $? -eq 2",
+    "lint": "eslint src/",
+    "_prepublishOnly_disabled": "npm run lint && npm run flow && npm run test && npm run build",
+    "eslint": "eslint src --fix",
+    "prettier": "--config .prettierrc --write",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "watch": "npm run build -- --watch"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tuc-urz/olea.git",
+    "directory": "packages/libraries/redux-offline"
+  },
+  "author": "",
+  "license": "MIT",
+  "files": [
+    "package.json",
+    "LICENSE",
+    "README.md",
+    "lib/**/*",
+    "src/**/*"
+  ],
+  "dependencies": {
+    "@babel/runtime": "^7.27.1",
+    "redux-persist": "^6.0.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.27.2",
+    "@babel/core": "^7.27.1",
+    "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@babel/plugin-syntax-object-rest-spread": "^7.8.3",
+    "@babel/plugin-transform-flow-strip-types": "^7.27.1",
+    "@babel/plugin-transform-runtime": "^7.27.1",
+    "@babel/preset-env": "^7.27.2",
+    "babel-core": "^7.0.0-bridge.0",
+    "babel-eslint": "^10.1.0",
+    "babel-jest": "^29.7.0",
+    "eslint": "^8.2.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-babel": "^5.3.1",
+    "eslint-plugin-flowtype": "^8.0.3",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-prettier": "^5.4.0",
+    "flow-bin": "^0.272.1",
+    "husky": "^9.1.7",
+    "jest": "^29.7.0",
+    "lint-staged": "^16.0.0",
+    "prettier": "^3.5.3",
+    "redux": "^4.0.5",
+    "redux-devtools-instrument": "^1.10.0",
+    "redux-logger": "^3.0.6",
+    "redux-persist-node-storage": "^2.0.0",
+    "release": "^6.3.1"
+  },
+  "peerDependencies": {
+    "redux": ">=3"
+  }
+}