@dhis2/app-service-offline 3.16.0 → 3.17.0-beta.2

package/build/cjs/lib/dhis2-connection-status/dhis2-connection-status.test.js

@@ -31,26 +31,23 @@ const FOURTH_INTERVAL_MS = THIRD_INTERVAL_MS * _smartInterval.DEFAULT_INCREMENT_
 // N >= (ln (maxDelay / initialDelay) / ln (incrementFactor)) + 1
 // => then use Math.ceil to handle the 'greater than' effect
 const INTERVALS_TO_REACH_MAX_DELAY = Math.ceil(Math.log(_smartInterval.DEFAULT_MAX_DELAY_MS / _smartInterval.DEFAULT_INITIAL_DELAY_MS) / Math.log(_smartInterval.DEFAULT_INCREMENT_FACTOR) + 1);
-const wrapper = _ref => {
-  let {
-    children
-  } = _ref;
-  return /*#__PURE__*/_react2.default.createElement(_appServiceConfig.ConfigProvider, {
-    config: {
-      baseUrl: '..',
-      apiVersion: 42,
-      // ensure this is a server version where pings are enabled
-      serverVersion: {
-        major: 2,
-        minor: 40,
-        patch: 0,
-        full: 'n/a'
-      }
+const wrapper = ({
+  children
+}) => /*#__PURE__*/_react2.default.createElement(_appServiceConfig.ConfigProvider, {
+  config: {
+    baseUrl: '..',
+    apiVersion: 42,
+    // ensure this is a server version where pings are enabled
+    serverVersion: {
+      major: 2,
+      minor: 40,
+      patch: 0,
+      full: 'n/a'
     }
-  }, /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
-    offlineInterface: _testMocks.mockOfflineInterface
-  }, children));
-};
+  }
+}, /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
+  offlineInterface: _testMocks.mockOfflineInterface
+}, children));
 
 /**
  * Assert on the delay of the last time setTimeoutSpy was called with
@@ -105,14 +102,11 @@ describe('initialization to the right values based on offline interface', () =>
       ..._testMocks.mockOfflineInterface,
       latestIsConnected: false
     };
-    const customWrapper = _ref2 => {
-      let {
-        children
-      } = _ref2;
-      return /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
-        offlineInterface: customMockOfflineInterface
-      }, children);
-    };
+    const customWrapper = ({
+      children
+    }) => /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
+      offlineInterface: customMockOfflineInterface
+    }, children);
     const {
       result
     } = (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
@@ -137,14 +131,11 @@ describe('initialization to the right values based on offline interface', () =>
       ..._testMocks.mockOfflineInterface,
       latestIsConnected: null
     };
-    const customWrapper = _ref3 => {
-      let {
-        children
-      } = _ref3;
-      return /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
-        offlineInterface: customMockOfflineInterface
-      }, children);
-    };
+    const customWrapper = ({
+      children
+    }) => /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
+      offlineInterface: customMockOfflineInterface
+    }, children);
     const {
       result
     } = (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
@@ -689,14 +680,11 @@ describe('lastConnected status', () => {
         ..._testMocks.mockOfflineInterface,
         latestIsConnected: false
       };
-      const customWrapper = _ref4 => {
-        let {
-          children
-        } = _ref4;
-        return /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
-          offlineInterface: customMockOfflineInterface
-        }, children);
-      };
+      const customWrapper = ({
+        children
+      }) => /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
+        offlineInterface: customMockOfflineInterface
+      }, children);
 
       // render hook with custom wrapper
       (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
@@ -716,14 +704,11 @@ describe('lastConnected status', () => {
         ..._testMocks.mockOfflineInterface,
         latestIsConnected: false
       };
-      const customWrapper = _ref5 => {
-        let {
-          children
-        } = _ref5;
-        return /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
-          offlineInterface: customMockOfflineInterface
-        }, children);
-      };
+      const customWrapper = ({
+        children
+      }) => /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
+        offlineInterface: customMockOfflineInterface
+      }, children);
       const {
         result
       } = (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
@@ -747,25 +732,22 @@ describe('lastConnected status', () => {
       ..._testMocks.mockOfflineInterface,
       latestIsConnected: false
     };
-    const customWrapper = _ref6 => {
-      let {
-        children
-      } = _ref6;
-      return /*#__PURE__*/_react2.default.createElement(_appServiceConfig.ConfigProvider, {
-        config: {
-          baseUrl: '..',
-          apiVersion: 42,
-          serverVersion: {
-            major: 2,
-            minor: 40,
-            patch: 0,
-            full: 'n/a'
-          }
+    const customWrapper = ({
+      children
+    }) => /*#__PURE__*/_react2.default.createElement(_appServiceConfig.ConfigProvider, {
+      config: {
+        baseUrl: '..',
+        apiVersion: 42,
+        serverVersion: {
+          major: 2,
+          minor: 40,
+          patch: 0,
+          full: 'n/a'
         }
-      }, /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
-        offlineInterface: customMockOfflineInterface
-      }, children));
-    };
+      }
+    }, /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
+      offlineInterface: customMockOfflineInterface
+    }, children));
     const {
       result
     } = (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
@@ -813,26 +795,23 @@ describe('lastConnected status', () => {
       ..._testMocks.mockOfflineInterface,
       latestIsConnected: false
     };
-    const customWrapper = _ref7 => {
-      let {
-        children
-      } = _ref7;
-      return /*#__PURE__*/_react2.default.createElement(_appServiceConfig.ConfigProvider, {
-        config: {
-          baseUrl: '..',
-          apiVersion: 42,
-          appName: testAppName,
-          serverVersion: {
-            major: 2,
-            minor: 40,
-            patch: 0,
-            full: 'n/a'
-          }
+    const customWrapper = ({
+      children
+    }) => /*#__PURE__*/_react2.default.createElement(_appServiceConfig.ConfigProvider, {
+      config: {
+        baseUrl: '..',
+        apiVersion: 42,
+        appName: testAppName,
+        serverVersion: {
+          major: 2,
+          minor: 40,
+          patch: 0,
+          full: 'n/a'
         }
-      }, /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
-        offlineInterface: customMockOfflineInterface
-      }, children));
-    };
+      }
+    }, /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
+      offlineInterface: customMockOfflineInterface
+    }, children));
     const {
       result
     } = (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
@@ -862,26 +841,23 @@ describe('lastConnected status', () => {
   });
 });
 describe("when the /api/ping endpoint isn't supported", () => {
-  const customWrapper = _ref8 => {
-    let {
-      children
-    } = _ref8;
-    return /*#__PURE__*/_react2.default.createElement(_appServiceConfig.ConfigProvider, {
-      config: {
-        baseUrl: '..',
-        apiVersion: 42,
-        // an unsupported version:
-        serverVersion: {
-          major: 2,
-          minor: 39,
-          patch: 0,
-          full: 'n/a'
-        }
+  const customWrapper = ({
+    children
+  }) => /*#__PURE__*/_react2.default.createElement(_appServiceConfig.ConfigProvider, {
+    config: {
+      baseUrl: '..',
+      apiVersion: 42,
+      // an unsupported version:
+      serverVersion: {
+        major: 2,
+        minor: 39,
+        patch: 0,
+        full: 'n/a'
       }
-    }, /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
-      offlineInterface: _testMocks.mockOfflineInterface
-    }, children));
-  };
+    }
+  }, /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
+    offlineInterface: _testMocks.mockOfflineInterface
+  }, children));
   test("pings aren't sent", async () => {
     const setTimeoutSpy = jest.spyOn(window, 'setTimeout');
     (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {

package/build/cjs/lib/dhis2-connection-status/smart-interval.js

@@ -13,14 +13,13 @@ const DEFAULT_INCREMENT_FACTOR = exports.DEFAULT_INCREMENT_FACTOR = 1.5;
 const throwErrorIfNoCallbackIsProvided = () => {
   throw new Error('Provide a callback');
 };
-function createSmartInterval() {
-  let {
-    initialDelay = DEFAULT_INITIAL_DELAY_MS,
-    maxDelay = DEFAULT_MAX_DELAY_MS,
-    delayIncrementFactor = DEFAULT_INCREMENT_FACTOR,
-    initialPauseValue = false,
-    callback = throwErrorIfNoCallbackIsProvided
-  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+function createSmartInterval({
+  initialDelay = DEFAULT_INITIAL_DELAY_MS,
+  maxDelay = DEFAULT_MAX_DELAY_MS,
+  delayIncrementFactor = DEFAULT_INCREMENT_FACTOR,
+  initialPauseValue = false,
+  callback = throwErrorIfNoCallbackIsProvided
+} = {}) {
   const state = {
     paused: initialPauseValue,
     delay: initialDelay,

package/build/cjs/lib/global-state-service.js

@@ -15,8 +15,7 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
 // See more at https://github.com/amcgee/state-service-poc
 
 const identity = state => state;
-const createStore = function () {
-  let initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+const createStore = (initialState = {}) => {
   const subscriptions = new Set();
   let state = initialState;
   return {
@@ -38,22 +37,18 @@ const createStore = function () {
 exports.createStore = createStore;
 const GlobalStateContext = /*#__PURE__*/_react.default.createContext(createStore());
 const useGlobalStateStore = () => (0, _react.useContext)(GlobalStateContext);
-const GlobalStateProvider = _ref => {
-  let {
-    store,
-    children
-  } = _ref;
-  return /*#__PURE__*/_react.default.createElement(GlobalStateContext.Provider, {
-    value: store
-  }, children);
-};
+const GlobalStateProvider = ({
+  store,
+  children
+}) => /*#__PURE__*/_react.default.createElement(GlobalStateContext.Provider, {
+  value: store
+}, children);
 exports.GlobalStateProvider = GlobalStateProvider;
 GlobalStateProvider.propTypes = {
   children: _propTypes.default.node,
   store: _propTypes.default.shape({})
 };
-const useGlobalState = function () {
-  let selector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : identity;
+const useGlobalState = (selector = identity) => {
   const store = useGlobalStateStore();
   const [selectedState, setSelectedState] = (0, _react.useState)(selector(store.getState()));
   (0, _react.useEffect)(() => {
@@ -80,7 +75,7 @@ const useGlobalState = function () {
 exports.useGlobalState = useGlobalState;
 function useGlobalStateMutation(mutationCreator) {
   const store = useGlobalStateStore();
-  return (0, _react.useCallback)(function () {
-    store.mutate(mutationCreator(...arguments));
+  return (0, _react.useCallback)((...args) => {
+    store.mutate(mutationCreator(...args));
   }, [mutationCreator, store]);
 }

package/build/cjs/lib/network-status.js

@@ -26,17 +26,15 @@ const lastOnlineKey = 'dhis2.lastOnline';
  * @param {Number} [options.debounceDelay] - Timeout delay to debounce updates, in ms
  * @returns {Object} `{ online: boolean, offline: boolean, lastOnline: Date | null }`
  */
-function useNetworkStatus() {
+function useNetworkStatus(options = {}) {
   var _options$debounceDela;
-  let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   // initialize state to `navigator.onLine` value
   const [online, setOnline] = (0, _react.useState)(navigator.onLine);
 
   // eslint-disable-next-line react-hooks/exhaustive-deps
-  const updateState = (0, _react.useCallback)((0, _debounce.default)(_ref => {
-    let {
-      type
-    } = _ref;
+  const updateState = (0, _react.useCallback)((0, _debounce.default)(({
+    type
+  }) => {
     if (type === 'online') {
       setOnline(true);
     } else if (type === 'offline') {

package/build/cjs/lib/offline-interface.js

@@ -27,11 +27,10 @@ const OfflineInterfaceContext = /*#__PURE__*/(0, _react.createContext)(noopOffli
  * checks for service worker updates and, if updates are ready, prompts the
  * user with an alert to skip waiting and reload the page to use new content.
  */
-function OfflineInterfaceProvider(_ref) {
-  let {
-    offlineInterface,
-    children
-  } = _ref;
+function OfflineInterfaceProvider({
+  offlineInterface,
+  children
+}) {
   return /*#__PURE__*/_react.default.createElement(OfflineInterfaceContext.Provider, {
     value: offlineInterface
   }, children);

package/build/cjs/lib/offline-provider.js

@@ -12,11 +12,10 @@ var _offlineInterface = require("./offline-interface");
 var _onlineStatusMessage = require("./online-status-message");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /** A context provider for all the relevant offline contexts */
-function OfflineProvider(_ref) {
-  let {
-    offlineInterface,
-    children
-  } = _ref;
+function OfflineProvider({
+  offlineInterface,
+  children
+}) {
   // If an offline interface is not provided, or if one is provided and PWA
   // is not enabled, skip adding context providers
   if (!offlineInterface || !offlineInterface.pwaEnabled) {

package/build/cjs/lib/online-status-message.js

@@ -10,10 +10,9 @@ function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r
 // actually need the value don't have to rerender when the value changes:
 const OnlineStatusMessageValueContext = /*#__PURE__*/_react.default.createContext(undefined);
 const SetOnlineStatusMessageContext = /*#__PURE__*/_react.default.createContext(() => undefined);
-const OnlineStatusMessageProvider = _ref => {
-  let {
-    children
-  } = _ref;
+const OnlineStatusMessageProvider = ({
+  children
+}) => {
   const [onlineStatusMessage, setOnlineStatusMessage] = (0, _react.useState)(); // note: not undefined
 
   return /*#__PURE__*/_react.default.createElement(OnlineStatusMessageValueContext.Provider, {

package/build/cjs/utils/render-counter.js

@@ -6,11 +6,10 @@ Object.defineProperty(exports, "__esModule", {
 exports.resetRenderCounts = exports.RenderCounter = void 0;
 var _react = _interopRequireDefault(require("react"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const RenderCounter = _ref => {
-  let {
-    id,
-    countsObj
-  } = _ref;
+const RenderCounter = ({
+  id,
+  countsObj
+}) => {
   if (!(id in countsObj)) {
     countsObj[id] = 0;
   }

package/build/cjs/utils/test-mocks.js

@@ -4,11 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.successfulRecordingMock = exports.mockOfflineInterface = exports.failedMessageRecordingMock = exports.errorRecordingMock = void 0;
-const successfulRecordingMock = exports.successfulRecordingMock = jest.fn().mockImplementation(async function () {
-  let {
-    onStarted,
-    onCompleted
-  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+const successfulRecordingMock = exports.successfulRecordingMock = jest.fn().mockImplementation(async ({
+  onStarted,
+  onCompleted
+} = {}) => {
   // in 100ms, call 'onStarted' callback (allows 'pending' state)
   if (onStarted) {
     setTimeout(onStarted, 100);
@@ -22,11 +21,10 @@ const successfulRecordingMock = exports.successfulRecordingMock = jest.fn().mock
   // resolve
   return Promise.resolve();
 });
-const errorRecordingMock = exports.errorRecordingMock = jest.fn().mockImplementation(function () {
-  let {
-    onStarted,
-    onError
-  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+const errorRecordingMock = exports.errorRecordingMock = jest.fn().mockImplementation(({
+  onStarted,
+  onError
+} = {}) => {
   // in 100ms, call 'onStarted' callback (allows 'pending' state)
   if (onStarted) {
     setTimeout(onStarted, 100);

package/build/es/__tests__/integration.test.js

@@ -8,12 +8,11 @@ import { RenderCounter, resetRenderCounts } from '../utils/render-counter';
 import { errorRecordingMock, failedMessageRecordingMock, mockOfflineInterface } from '../utils/test-mocks';
 const renderCounts = {};
 const identity = arg => arg;
-const TestControls = _ref => {
+const TestControls = ({
+  id,
+  makeRecordingHandler = identity
+}) => {
   var _lastUpdated$toISOStr;
-  let {
-    id,
-    makeRecordingHandler = identity
-  } = _ref;
   const {
     startRecording,
     remove,
@@ -40,21 +39,18 @@ const TestControls = _ref => {
     "data-testid": `recording-state-${id}`
   }, recordingState));
 };
-const TestSection = _ref2 => {
-  let {
-    id,
-    children
-  } = _ref2;
-  return /*#__PURE__*/React.createElement(CacheableSection, {
-    id: id,
-    loadingMask: /*#__PURE__*/React.createElement("div", {
-      "data-testid": `loading-mask-${id}`
-    })
-  }, /*#__PURE__*/React.createElement(RenderCounter, {
-    id: `section-rc-${id}`,
-    countsObj: renderCounts
-  }), children);
-};
+const TestSection = ({
+  id,
+  children
+}) => /*#__PURE__*/React.createElement(CacheableSection, {
+  id: id,
+  loadingMask: /*#__PURE__*/React.createElement("div", {
+    "data-testid": `loading-mask-${id}`
+  })
+}, /*#__PURE__*/React.createElement(RenderCounter, {
+  id: `section-rc-${id}`,
+  countsObj: renderCounts
+}), children);
 const TestSingleSection = props => {
   // Props are spread so they can be overwritten
   return /*#__PURE__*/React.createElement(AlertsProvider, null, /*#__PURE__*/React.createElement(OfflineProvider, _extends({
@@ -71,11 +67,8 @@ const originalError = console.error;
 beforeEach(() => {
   // This is done before each because the 'recording error' test uses its own
   // spy on console.error
-  jest.spyOn(console, 'error').mockImplementation(function () {
+  jest.spyOn(console, 'error').mockImplementation((...args) => {
     const pattern = /Warning: An update to .* inside a test was not wrapped in act/;
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
     if (typeof args[0] === 'string' && pattern.test(args[0])) {
       return;
     }
@@ -85,7 +78,7 @@ beforeEach(() => {
 afterEach(() => {
   jest.clearAllMocks()
   // This syntax appeases typescript:
-  ;
+;
   console.error.mockRestore();
   resetRenderCounts(renderCounts);
 });
@@ -137,12 +130,9 @@ describe('Coordination between useCacheableSection and CacheableSection', () =>
   });
   it('handles a recording that encounters an error', async done => {
     // Suppress the expected error from console (in addition to 'act' warning)
-    jest.spyOn(console, 'error').mockImplementation(function () {
+    jest.spyOn(console, 'error').mockImplementation((...args) => {
       const actPattern = /Warning: An update to .* inside a test was not wrapped in act/;
       const errPattern = /Error during recording/;
-      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-        args[_key2] = arguments[_key2];
-      }
       const matchesPattern = actPattern.test(args[0]) || errPattern.test(args[0]);
       if (typeof args[0] === 'string' && matchesPattern) {
         return;

package/build/es/lib/__tests__/cacheable-section-state.test.js

@@ -3,14 +3,11 @@ import React from 'react';
 import { mockOfflineInterface } from '../../utils/test-mocks';
 import { useCachedSection, useRecordingState } from '../cacheable-section-state';
 import { OfflineProvider } from '../offline-provider';
-const wrapper = _ref => {
-  let {
-    children
-  } = _ref;
-  return /*#__PURE__*/React.createElement(OfflineProvider, {
-    offlineInterface: mockOfflineInterface
-  }, children);
-};
+const wrapper = ({
+  children
+}) => /*#__PURE__*/React.createElement(OfflineProvider, {
+  offlineInterface: mockOfflineInterface
+}, children);
 test('useRecordingState has stable references', () => {
   const {
     result,

package/build/es/lib/__tests__/clear-sensitive-caches.test.js

@@ -28,11 +28,8 @@ afterEach(() => {
 // silence debug logs for these tests
 const originalDebug = console.debug;
 beforeAll(() => {
-  jest.spyOn(console, 'debug').mockImplementation(function () {
+  jest.spyOn(console, 'debug').mockImplementation((...args) => {
     const pattern = /Clearing sensitive caches/;
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
     if (typeof args[0] === 'string' && pattern.test(args[0])) {
       return;
     }