@dhis2/app-service-offline 3.11.3 → 3.12.0-alpha.1

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

@@ -4,28 +4,20 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.resetRenderCounts = exports.RenderCounter = void 0;
-
 var _react = _interopRequireDefault(require("react"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const RenderCounter = (_ref) => {
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const RenderCounter = _ref => {
   let {
     id,
     countsObj
   } = _ref;
-
   if (!(id in countsObj)) {
     countsObj[id] = 0;
   }
-
   return /*#__PURE__*/_react.default.createElement("div", {
     "data-testid": id
   }, ++countsObj[id]);
 };
-
 exports.RenderCounter = RenderCounter;
-
 const resetRenderCounts = renderCounts => Object.keys(renderCounts).forEach(key => renderCounts[key] = 0);
-
 exports.resetRenderCounts = resetRenderCounts;

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

@@ -4,46 +4,42 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.successfulRecordingMock = exports.mockOfflineInterface = exports.failedMessageRecordingMock = exports.errorRecordingMock = void 0;
-const successfulRecordingMock = jest.fn().mockImplementation(async function () {
+const successfulRecordingMock = exports.successfulRecordingMock = jest.fn().mockImplementation(async function () {
   let {
     onStarted,
     onCompleted
   } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-
   // in 100ms, call 'onStarted' callback (allows 'pending' state)
   if (onStarted) {
     setTimeout(onStarted, 100);
-  } // in 200ms, call 'onCompleted' callback
-
+  }
 
+  // in 200ms, call 'onCompleted' callback
   if (onCompleted) {
     setTimeout(onCompleted, 200);
-  } // resolve
-
+  }
 
+  // resolve
   return Promise.resolve();
 });
-exports.successfulRecordingMock = successfulRecordingMock;
-const errorRecordingMock = jest.fn().mockImplementation(function () {
+const errorRecordingMock = exports.errorRecordingMock = jest.fn().mockImplementation(function () {
   let {
     onStarted,
     onError
   } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-
   // in 100ms, call 'onStarted' callback (allows 'pending' state)
   if (onStarted) {
     setTimeout(onStarted, 100);
-  } // in 200ms, call 'onError'
-
+  }
 
-  setTimeout(() => onError(new Error('test err')), 200); // resolve to signal successful initiation
+  // in 200ms, call 'onError'
+  setTimeout(() => onError(new Error('test err')), 200);
 
+  // resolve to signal successful initiation
   return Promise.resolve();
 });
-exports.errorRecordingMock = errorRecordingMock;
-const failedMessageRecordingMock = jest.fn().mockRejectedValue(new Error('Failed message'));
-exports.failedMessageRecordingMock = failedMessageRecordingMock;
-const mockOfflineInterface = {
+const failedMessageRecordingMock = exports.failedMessageRecordingMock = jest.fn().mockRejectedValue(new Error('Failed message'));
+const mockOfflineInterface = exports.mockOfflineInterface = {
   pwaEnabled: true,
   latestIsConnected: true,
   startRecording: successfulRecordingMock,
@@ -51,5 +47,4 @@ const mockOfflineInterface = {
   removeSection: jest.fn().mockResolvedValue(true),
   // returns an unsubscribe function
   subscribeToDhis2ConnectionStatus: jest.fn().mockReturnValue(() => undefined)
-};
-exports.mockOfflineInterface = mockOfflineInterface;
+};

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

@@ -1,17 +1,15 @@
-function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
-
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
 import { AlertsProvider } from '@dhis2/app-service-alerts';
-import { act, fireEvent, render, screen } from '@testing-library/react';
+import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
 import React from 'react';
 import { useCacheableSection, CacheableSection } from '../lib/cacheable-section';
 import { OfflineProvider } from '../lib/offline-provider';
 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 = _ref => {
+  var _lastUpdated$toISOStr;
   let {
     id,
     makeRecordingHandler = identity
@@ -38,12 +36,11 @@ const TestControls = (_ref) => {
     "data-testid": `is-cached-${id}`
   }, isCached ? 'yes' : 'no'), /*#__PURE__*/React.createElement("div", {
     "data-testid": `last-updated-${id}`
-  }, lastUpdated || 'never'), /*#__PURE__*/React.createElement("div", {
+  }, (_lastUpdated$toISOStr = lastUpdated === null || lastUpdated === void 0 ? void 0 : lastUpdated.toISOString()) !== null && _lastUpdated$toISOStr !== void 0 ? _lastUpdated$toISOStr : 'never'), /*#__PURE__*/React.createElement("div", {
     "data-testid": `recording-state-${id}`
   }, recordingState));
 };
-
-const TestSection = (_ref2) => {
+const TestSection = _ref2 => {
   let {
     id,
     children
@@ -58,7 +55,6 @@ const TestSection = (_ref2) => {
     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({
@@ -68,36 +64,34 @@ const TestSingleSection = props => {
   }, props)), /*#__PURE__*/React.createElement(TestSection, _extends({
     id: '1'
   }, props))));
-}; // Suppress 'act' warning for these tests
-
+};
 
+// Suppress 'act' warning for these tests
 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 () {
     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;
     }
-
     return originalError.call(console, ...args);
   });
 });
 afterEach(() => {
-  jest.clearAllMocks() // This syntax appeases typescript:
+  jest.clearAllMocks()
+  // This syntax appeases typescript:
   ;
   console.error.mockRestore();
   resetRenderCounts(renderCounts);
 });
 describe('Coordination between useCacheableSection and CacheableSection', () => {
   it('renders in the default state initially', async () => {
-    render( /*#__PURE__*/React.createElement(TestSingleSection, null));
+    render(/*#__PURE__*/React.createElement(TestSingleSection, null));
     const {
       getByTestId
     } = screen;
@@ -112,35 +106,31 @@ describe('Coordination between useCacheableSection and CacheableSection', () =>
       getByTestId,
       queryByTestId
     } = screen;
-
     const onStarted = () => {
       expect(getByTestId(/recording-state/)).toHaveTextContent('recording');
       expect(getByTestId(/loading-mask/)).toBeInTheDocument();
       expect(getByTestId(/section-rc/)).toBeInTheDocument();
     };
-
     const onCompleted = () => {
       expect(getByTestId(/recording-state/)).toHaveTextContent('default');
       expect(queryByTestId(/loading-mask/)).not.toBeInTheDocument();
       done();
     };
-
     const recordingOptions = {
       onStarted,
       onCompleted
     };
-
     const makeRecordingHandler = startRecording => {
       return () => startRecording(recordingOptions);
     };
-
-    render( /*#__PURE__*/React.createElement(TestSingleSection, {
+    render(/*#__PURE__*/React.createElement(TestSingleSection, {
       makeRecordingHandler: makeRecordingHandler
     }));
     await act(async () => {
       fireEvent.click(getByTestId(/start-recording/));
-    }); // At this stage, should be pending
+    });
 
+    // At this stage, should be pending
     expect(getByTestId(/recording-state/)).toHaveTextContent('pending');
     expect(queryByTestId(/section-rc/)).not.toBeInTheDocument();
     expect.assertions(7);
@@ -150,41 +140,35 @@ describe('Coordination between useCacheableSection and CacheableSection', () =>
     jest.spyOn(console, 'error').mockImplementation(function () {
       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;
       }
-
       return originalError.call(console, ...args);
     });
     const {
       getByTestId,
       queryByTestId
     } = screen;
-    const testOfflineInterface = { ...mockOfflineInterface,
+    const testOfflineInterface = {
+      ...mockOfflineInterface,
       startRecording: errorRecordingMock
     };
-
     const onError = () => {
       expect(getByTestId(/recording-state/)).toHaveTextContent('error');
       expect(queryByTestId(/loading-mask/)).not.toBeInTheDocument();
       expect(getByTestId(/section-rc/)).toBeInTheDocument();
       done();
     };
-
     const makeRecordingHandler = startRecording => {
       return () => startRecording({
         onError
       });
     };
-
-    render( /*#__PURE__*/React.createElement(TestSingleSection, {
+    render(/*#__PURE__*/React.createElement(TestSingleSection, {
       offlineInterface: testOfflineInterface,
       makeRecordingHandler: makeRecordingHandler
     }));
@@ -192,33 +176,31 @@ describe('Coordination between useCacheableSection and CacheableSection', () =>
       fireEvent.click(getByTestId(/start-recording/));
     });
     expect.assertions(3);
-  }); // ! After bumping testing-library versions, something about this test
-  // ! causes the following ones to mysteriously fail 😤
+  });
 
+  // ! After bumping testing-library versions, something about this test
+  // ! causes the following ones to mysteriously fail 😤
   it.skip('handles an error starting the recording', async done => {
     const {
       getByTestId
     } = screen;
-    const testOfflineInterface = { ...mockOfflineInterface,
+    const testOfflineInterface = {
+      ...mockOfflineInterface,
       startRecording: failedMessageRecordingMock
     };
     const onStarted = jest.fn();
-
     const testErrCondition = err => {
       expect(err.message).toBe('Failed message'); // from the mock
-
       expect(onStarted).not.toHaveBeenCalled();
       expect(getByTestId(/recording-state/)).toHaveTextContent('default');
       done();
     };
-
     const makeRecordingHandler = startRecording => {
       return () => startRecording({
         onStarted
       }).catch(testErrCondition);
     };
-
-    render( /*#__PURE__*/React.createElement(TestSingleSection, {
+    render(/*#__PURE__*/React.createElement(TestSingleSection, {
       offlineInterface: testOfflineInterface,
       makeRecordingHandler: makeRecordingHandler
     }));
@@ -227,7 +209,6 @@ describe('Coordination between useCacheableSection and CacheableSection', () =>
     });
   });
 });
-
 const TwoTestSections = props =>
 /*#__PURE__*/
 // Props are spread so they can be overwritten (but only on one section)
@@ -241,44 +222,42 @@ React.createElement(AlertsProvider, null, /*#__PURE__*/React.createElement(Offli
   id: '2'
 }), /*#__PURE__*/React.createElement(TestSection, {
   id: '2'
-}))); // test that other sections don't rerender when one section does
-
+})));
 
+// test that other sections don't rerender when one section does
 describe('Performant state management', () => {
   it('establishes a pre-recording render count', () => {
-    render( /*#__PURE__*/React.createElement(TwoTestSections, null));
+    render(/*#__PURE__*/React.createElement(TwoTestSections, null));
     const {
       getByTestId
-    } = screen; // Two renders for controls: undefined and 'default' states
-
+    } = screen;
+    // Two renders for controls: undefined and 'default' states
     expect(getByTestId('controls-rc-1')).toHaveTextContent('2');
-    expect(getByTestId('controls-rc-2')).toHaveTextContent('2'); // Just one render for sections
-
+    expect(getByTestId('controls-rc-2')).toHaveTextContent('2');
+    // Just one render for sections
     expect(getByTestId('section-rc-1')).toHaveTextContent('1');
     expect(getByTestId('section-rc-2')).toHaveTextContent('1');
   });
   it('isolates rerenders from other consumers', async done => {
     const {
       getByTestId
-    } = screen; // Make assertions
-
+    } = screen;
+    // Make assertions
     const onCompleted = () => {
       // Before refactor: controls components have 6 renders EACH, and
       // sections 1 and 2 have 2 and 1 renders, respectively
       // After refactor, render counts for section that recorded:
       expect(getByTestId('controls-rc-1')).toHaveTextContent('5');
-      expect(getByTestId('section-rc-1')).toHaveTextContent('2'); // Section that did not record (should be same as pre-recording):
-
+      expect(getByTestId('section-rc-1')).toHaveTextContent('2');
+      // Section that did not record (should be same as pre-recording):
       expect(getByTestId('controls-rc-2')).toHaveTextContent('2');
       expect(getByTestId('section-rc-2')).toHaveTextContent('1');
       done();
     };
-
     const makeRecordingHandler = startRecording => () => startRecording({
       onCompleted
     });
-
-    render( /*#__PURE__*/React.createElement(TwoTestSections, {
+    render(/*#__PURE__*/React.createElement(TwoTestSections, {
       makeRecordingHandler: makeRecordingHandler
     }));
     await act(async () => {
@@ -298,44 +277,42 @@ describe('useCacheableSection can be used inside a child of CacheableSection', (
       id: '1'
     }, props)))));
   };
-
   it('handles a successful recording', async done => {
     const {
       getByTestId,
       queryByTestId
     } = screen;
-
-    const onStarted = () => {
-      expect(getByTestId(/recording-state/)).toHaveTextContent('recording');
-      expect(getByTestId(/loading-mask/)).toBeInTheDocument();
-      expect(getByTestId(/section-rc/)).toBeInTheDocument();
+    const onStarted = async () => {
+      await waitFor(() => {
+        expect(getByTestId(/recording-state/)).toHaveTextContent('recording');
+        expect(getByTestId(/loading-mask/)).toBeInTheDocument();
+        expect(getByTestId(/section-rc/)).toBeInTheDocument();
+      });
     };
-
     const onCompleted = () => {
       expect(getByTestId(/recording-state/)).toHaveTextContent('default');
       expect(queryByTestId(/loading-mask/)).not.toBeInTheDocument();
       done();
     };
-
     const recordingOptions = {
       onStarted,
       onCompleted
     };
-
     const makeRecordingHandler = startRecording => {
       return () => startRecording(recordingOptions);
     };
-
-    render( /*#__PURE__*/React.createElement(ChildTest, {
+    render(/*#__PURE__*/React.createElement(ChildTest, {
       makeRecordingHandler: makeRecordingHandler
     }));
     await act(async () => {
-      fireEvent.click(getByTestId(/start-recording/));
-    }); // At this stage, should be pending
-    // - In this test case, 'controls' should not be rendered
-
-    expect(queryByTestId(/recording-state/)).not.toBeInTheDocument();
-    expect(queryByTestId(/section-rc/)).not.toBeInTheDocument();
-    expect.assertions(7);
+      await fireEvent.click(getByTestId(/start-recording/));
+    });
+    await waitFor(() => {
+      // At this stage, should be pending
+      // - In this test case, 'controls' should not be rendered
+      expect(queryByTestId(/recording-state/)).not.toBeInTheDocument();
+      expect(queryByTestId(/section-rc/)).not.toBeInTheDocument();
+      expect.assertions(7);
+    });
   });
 });

package/build/es/index.js

@@ -1,7 +1,7 @@
 export { OfflineProvider } from './lib/offline-provider';
 export { CacheableSection, useCacheableSection } from './lib/cacheable-section';
-export { useCachedSections } from './lib/cacheable-section-state'; // Use "useOnlineStatus" name for backwards compatibility
-
+export { useCachedSections } from './lib/cacheable-section-state';
+// Use "useOnlineStatus" name for backwards compatibility
 export { useNetworkStatus as useOnlineStatus } from './lib/network-status';
 export { useOnlineStatusMessage, useSetOnlineStatusMessage, useOnlineStatusMessageValue } from './lib/online-status-message';
 export { clearSensitiveCaches } from './lib/clear-sensitive-caches';

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

@@ -1,10 +1,9 @@
-import { renderHook } from '@testing-library/react-hooks';
+import { renderHook } from '@testing-library/react';
 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) => {
+const wrapper = _ref => {
   let {
     children
   } = _ref;
@@ -12,7 +11,6 @@ const wrapper = (_ref) => {
     offlineInterface: mockOfflineInterface
   }, children);
 };
-
 test('useRecordingState has stable references', () => {
   const {
     result,

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

@@ -1,13 +1,14 @@
 import FDBFactory from 'fake-indexeddb/lib/FDBFactory';
 import { openDB } from 'idb';
 import 'fake-indexeddb/auto';
-import { clearSensitiveCaches, SECTIONS_DB, SECTIONS_STORE } from '../clear-sensitive-caches'; // Mocks for CacheStorage API
-// Returns true if an existing cache is deleted
+import { clearSensitiveCaches, SECTIONS_DB, SECTIONS_STORE } from '../clear-sensitive-caches';
+
+// Mocks for CacheStorage API
 
+// Returns true if an existing cache is deleted
 const makeCachesDeleteMock = keys => {
   return jest.fn().mockImplementation(key => Promise.resolve(keys.includes(key)));
 };
-
 const keysMockDefault = jest.fn().mockImplementation(async () => []);
 const deleteMockDefault = makeCachesDeleteMock([]);
 const cachesDefault = {
@@ -22,21 +23,19 @@ window.caches = cachesDefault;
 afterEach(() => {
   window.caches = cachesDefault;
   jest.clearAllMocks();
-}); // silence debug logs for these tests
+});
 
+// silence debug logs for these tests
 const originalDebug = console.debug;
 beforeAll(() => {
   jest.spyOn(console, 'debug').mockImplementation(function () {
     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;
     }
-
     return originalDebug.call(console, ...args);
   });
 });
@@ -51,7 +50,8 @@ it('returns false if caches.keys throws', async () => {
   const spy = jest.fn(() => {
     throw new Error('Security Error');
   });
-  window.caches = { ...cachesDefault,
+  window.caches = {
+    ...cachesDefault,
     keys: spy
   };
   const result = await clearSensitiveCaches();
@@ -62,7 +62,8 @@ it('clears potentially sensitive caches', async () => {
   const testKeys = ['cache1', 'cache2', 'app-shell', 'other-assets'];
   const keysMock = jest.fn().mockImplementation(() => Promise.resolve(testKeys));
   const deleteMock = makeCachesDeleteMock(testKeys);
-  window.caches = { ...cachesDefault,
+  window.caches = {
+    ...cachesDefault,
     keys: keysMock,
     delete: deleteMock
   };
@@ -76,7 +77,8 @@ it('clears potentially sensitive caches', async () => {
 });
 it('preserves keepable caches', async () => {
   const keysMock = jest.fn().mockImplementation(async () => ['cache1', 'cache2', 'app-shell', 'other-assets', 'workbox-precache-v2-https://hey.howareya.now/']);
-  window.caches = { ...cachesDefault,
+  window.caches = {
+    ...cachesDefault,
     keys: keysMock
   };
   await clearSensitiveCaches();
@@ -97,10 +99,8 @@ describe('clears sections-db', () => {
           keyPath: 'sectionId'
         });
       }
-
     });
   }
-
   afterEach(() => {
     // reset indexedDB state
     window.indexedDB = new FDBFactory();
@@ -118,8 +118,9 @@ describe('clears sections-db', () => {
       lastUpdated: new Date(),
       requests: 3
     });
-    await clearSensitiveCaches(); // Sections-db should be cleared
+    await clearSensitiveCaches();
 
+    // Sections-db should be cleared
     const allSections = await db.getAll(SECTIONS_STORE);
     expect(allSections).toHaveLength(0);
   });
@@ -136,16 +137,18 @@ describe('clears sections-db', () => {
     // if 'databases' property exists
     await openTestDB(SECTIONS_DB);
     const openMock = jest.fn();
-    window.indexedDB.open = openMock; // Remove 'databases' from indexedDB prototype for this test
-    // (simulates Firefox environment)
+    window.indexedDB.open = openMock;
 
+    // Remove 'databases' from indexedDB prototype for this test
+    // (simulates Firefox environment)
     const idbProto = Object.getPrototypeOf(window.indexedDB);
     const databases = idbProto.databases;
     delete idbProto.databases;
     expect('databases' in window.indexedDB).toBe(false);
     await expect(clearSensitiveCaches()).resolves.toBeDefined();
-    expect(openMock).not.toHaveBeenCalled(); // Restore indexedDB prototype for later tests
+    expect(openMock).not.toHaveBeenCalled();
 
+    // Restore indexedDB prototype for later tests
     idbProto.databases = databases;
     expect('databases' in window.indexedDB).toBe(true);
   });