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

package/build/es/lib/dhis2-connection-status/is-ping-available.js

@@ -14,22 +14,17 @@ export function isPingAvailable(serverVersion) {
   if (!serverVersion) {
     return false;
   }
-
   const {
     minor,
     patch
   } = serverVersion;
-
   switch (minor) {
     case 39:
       return patch === undefined || patch >= 2;
-
     case 38:
       return patch === undefined || patch >= 4;
-
     case 37:
       return patch === undefined || patch >= 10;
-
     default:
       return minor >= 40;
   }

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

@@ -1,15 +1,12 @@
-import { devDebugLog } from './dev-debug-log'; // Exported for tests
+import { devDebugLog } from './dev-debug-log';
 
+// Exported for tests
 export const DEFAULT_INITIAL_DELAY_MS = 1000 * 30; // 30 sec
-
 export const DEFAULT_MAX_DELAY_MS = 1000 * 60 * 5; // 5 min
-
 export const DEFAULT_INCREMENT_FACTOR = 1.5;
-
 const throwErrorIfNoCallbackIsProvided = () => {
   throw new Error('Provide a callback');
 };
-
 export default function createSmartInterval() {
   let {
     initialDelay = DEFAULT_INITIAL_DELAY_MS,
@@ -28,8 +25,8 @@ export default function createSmartInterval() {
     }, 0),
     standbyCallback: null
   };
-  /** Increment delay by the increment factor, up to a max value */
 
+  /** Increment delay by the increment factor, up to a max value */
   function incrementDelay() {
     const newDelay = Math.min(state.delay * delayIncrementFactor, maxDelay);
     devDebugLog('[SI] incrementing delay', {
@@ -38,51 +35,51 @@ export default function createSmartInterval() {
     });
     state.delay = newDelay;
   }
-
   function invokeCallbackAndHandleDelay() {
     // Increment delay before calling callback, so callback can potentially
     // reset the delay to initial before starting the next timeout
     incrementDelay();
     callback();
   }
-
   function clearTimeoutAndStart() {
     devDebugLog('[SI] clearing and starting timeout', {
       delay: state.delay
-    }); // Prevent parallel timeouts from occuring
+    });
+
+    // Prevent parallel timeouts from occuring
     // (weird note: `if (this.timeout) { clearTimeout(this.timeout) }`
     // does NOT work for some reason)
+    clearTimeout(state.timeout);
 
-    clearTimeout(state.timeout); // A timeout is used instead of an interval for handling slow execution
+    // A timeout is used instead of an interval for handling slow execution
     // https://developer.mozilla.org/en-US/docs/Web/API/setInterval#ensure_that_execution_duration_is_shorter_than_interval_frequency
-
     state.timeout = setTimeout(function callbackAndRestart() {
       if (state.paused) {
-        devDebugLog('[SI] entering regular standby'); // If paused, prepare a 'standby callback' to be invoked when
+        devDebugLog('[SI] entering regular standby');
+
+        // If paused, prepare a 'standby callback' to be invoked when
         // `resume()` is called (see its definition below).
         // The timer will not be started again until the standbyCallback
         // is invoked.
-
         state.standbyCallback = () => {
           invokeCallbackAndHandleDelay();
           clearTimeoutAndStart();
         };
-
         return;
-      } // Otherwise, invoke callback
-
-
-      invokeCallbackAndHandleDelay(); // and start process over again
+      }
 
+      // Otherwise, invoke callback
+      invokeCallbackAndHandleDelay();
+      // and start process over again
       clearTimeoutAndStart();
     }, state.delay);
   }
-  /** Stop the interval. Used for cleaning up */
-
 
+  /** Stop the interval. Used for cleaning up */
   function clear() {
     clearTimeout(state.timeout);
   }
+
   /**
    * Invoke the provided callback immediately and start the timer over.
    * The timeout to the next invocation will not be increased
@@ -94,8 +91,6 @@ export default function createSmartInterval() {
    * elapses while paused, the regular standby is entered, overwriting this
    * partial standby.
    */
-
-
   function invokeCallbackImmediately() {
     if (state.paused) {
       if (state.standbyCallback === null) {
@@ -107,22 +102,22 @@ export default function createSmartInterval() {
         // overwrite this callback if the timer elapses, so that the
         // timeout delay gets incremented appropriately.
         devDebugLog('[SI] entering standby without timer increment');
-
         state.standbyCallback = () => {
           // Invoke callback and start timer without incrementing
           callback();
           clearTimeoutAndStart();
         };
-      } // Skip rest of execution while paused
-
+      }
 
+      // Skip rest of execution while paused
       return;
-    } // Invoke callback and start timer without incrementing
-
+    }
 
+    // Invoke callback and start timer without incrementing
     callback();
     clearTimeoutAndStart();
   }
+
   /**
    * Sets a 'paused' flag (doesn't yet stop the timer):
    *
@@ -133,35 +128,35 @@ export default function createSmartInterval() {
    *
    * This decreases execution activity while 'paused'
    */
-
-
   function pause() {
     devDebugLog('[SI] pausing');
     state.paused = true;
   }
+
   /**
    * Removes 'paused' state
    *
    * If the interval is in 'standby', trigger the saved 'standbyCallback',
    * which should start the interval timer again
    */
-
-
   function resume() {
     devDebugLog('[SI] resuming', {
       standbyCb: state.standbyCallback
-    }); // Clear paused state
+    });
 
-    state.paused = false; // If in standby, invoke the saved callback
+    // Clear paused state
+    state.paused = false;
+
+    // If in standby, invoke the saved callback
     // (invokeCallbackImmediately and clearTimeoutAndStart can set a
     // standby callback)
-
     if (state.standbyCallback !== null) {
-      state.standbyCallback(); // Remove existing standbyCallback
-
+      state.standbyCallback();
+      // Remove existing standbyCallback
       state.standbyCallback = null;
     }
   }
+
   /**
    * Restart the timer to the next callback invocation, using the current
    * delay
@@ -169,24 +164,21 @@ export default function createSmartInterval() {
    * Expected to be called to delay a ping in response to incidental network
    * traffic, for example
    */
-
-
   function snooze() {
     devDebugLog('[SI] snoozing timeout');
     clearTimeoutAndStart();
   }
+
   /**
    * Cancels the current timeout and starts a new one with the initial delay
    */
-
-
   function reset() {
     devDebugLog('[SI] resetting interval from beginning');
     state.delay = initialDelay;
     clearTimeoutAndStart();
-  } // Start the timer!
-
+  }
 
+  // Start the timer!
   clearTimeoutAndStart();
   return {
     clear,

package/build/es/lib/dhis2-connection-status/use-ping-query.js

@@ -1,12 +1,15 @@
 import { useConfig } from '@dhis2/app-service-config';
-import { useCallback } from 'react'; // This function has a separate file for easier mocking
+import { useCallback } from 'react';
+
+// This function has a separate file for easier mocking
 
 export function usePingQuery() {
   const {
     baseUrl
-  } = useConfig(); // This endpoint doesn't need any extra headers or handling since it's
-  // public. It doesn't extend the user session. See DHIS2-14531
+  } = useConfig();
 
+  // This endpoint doesn't need any extra headers or handling since it's
+  // public. It doesn't extend the user session. See DHIS2-14531
   const ping = useCallback(() => fetch(baseUrl + '/api/ping'), [baseUrl]);
   return ping;
 }

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

@@ -1,12 +1,11 @@
 import isEqual from 'lodash/isEqual';
 import PropTypes from 'prop-types';
 import React, { useEffect, useCallback, useContext, useState, useMemo } from 'react';
-
 // This file creates a redux-like state management service using React context
 // that minimizes unnecessary rerenders that consume the context.
 // See more at https://github.com/amcgee/state-service-poc
-const identity = state => state;
 
+const identity = state => state;
 export const createStore = function () {
   let initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   const subscriptions = new Set();
@@ -21,7 +20,6 @@ export const createStore = function () {
     },
     mutate: mutation => {
       state = mutation(state);
-
       for (const callback of subscriptions) {
         callback(state);
       }
@@ -29,10 +27,8 @@ export const createStore = function () {
   };
 };
 const GlobalStateContext = /*#__PURE__*/React.createContext(createStore());
-
 const useGlobalStateStore = () => useContext(GlobalStateContext);
-
-export const GlobalStateProvider = (_ref) => {
+export const GlobalStateProvider = _ref => {
   let {
     store,
     children
@@ -52,21 +48,19 @@ export const useGlobalState = function () {
   useEffect(() => {
     // NEW: deep equality check before updating
     const callback = state => {
-      const newSelectedState = selector(state); // Use this form to avoid having `selectedState` as a dep in here
-
+      const newSelectedState = selector(state);
+      // Use this form to avoid having `selectedState` as a dep in here
       setSelectedState(currentSelectedState => {
         // Second condition handles case where a selected object gets
         // deleted, but state does not update
         if (!isEqual(currentSelectedState, newSelectedState) || currentSelectedState === undefined) {
           return newSelectedState;
         }
-
         return currentSelectedState;
       });
     };
-
-    store.subscribe(callback); // Make sure to update state when selector changes
-
+    store.subscribe(callback);
+    // Make sure to update state when selector changes
     callback(store.getState());
     return () => store.unsubscribe(callback);
   }, [store, selector]);

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

@@ -1,6 +1,8 @@
 import debounce from 'lodash/debounce';
 import { useState, useEffect, useCallback, useMemo } from 'react';
-const lastOnlineKey = 'dhis2.lastOnline'; // TODO: Add option to periodically ping server to check online status.
+const lastOnlineKey = 'dhis2.lastOnline';
+
+// TODO: Add option to periodically ping server to check online status.
 // TODO: Add logic to return a variable indicating unstable connection.
 
 /**
@@ -17,30 +19,28 @@ const lastOnlineKey = 'dhis2.lastOnline'; // TODO: Add option to periodically pi
  * @param {Number} [options.debounceDelay] - Timeout delay to debounce updates, in ms
  * @returns {Object} `{ online: boolean, offline: boolean, lastOnline: Date | null }`
  */
-
 export function useNetworkStatus() {
   var _options$debounceDela;
-
   let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   // initialize state to `navigator.onLine` value
-  const [online, setOnline] = useState(navigator.onLine); // eslint-disable-next-line react-hooks/exhaustive-deps
+  const [online, setOnline] = useState(navigator.onLine);
 
-  const updateState = useCallback(debounce((_ref) => {
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  const updateState = useCallback(debounce(_ref => {
     let {
       type
     } = _ref;
-
     if (type === 'online') {
       setOnline(true);
     } else if (type === 'offline') {
       if (online || !localStorage.getItem(lastOnlineKey)) {
         localStorage.setItem(lastOnlineKey, new Date(Date.now()).toUTCString());
       }
-
       setOnline(false);
     }
-  }, (_options$debounceDela = options.debounceDelay) !== null && _options$debounceDela !== void 0 ? _options$debounceDela : 1000), [options.debounceDelay]); // on 'online' or 'offline' events, set state
+  }, (_options$debounceDela = options.debounceDelay) !== null && _options$debounceDela !== void 0 ? _options$debounceDela : 1000), [options.debounceDelay]);
 
+  // on 'online' or 'offline' events, set state
   useEffect(() => {
     window.addEventListener('online', updateState);
     window.addEventListener('offline', updateState);
@@ -49,8 +49,9 @@ export function useNetworkStatus() {
       window.removeEventListener('online', updateState);
       window.removeEventListener('offline', updateState);
     };
-  }, [updateState]); // Only fetch if `online === false` as local storage is synchronous and disk-based
+  }, [updateState]);
 
+  // Only fetch if `online === false` as local storage is synchronous and disk-based
   const lastOnline = useMemo(() => !online && localStorage.getItem(lastOnlineKey), [online]);
   return {
     online,

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

@@ -10,7 +10,6 @@ const noopOfflineInterface = {
   removeSection: async () => false
 };
 const OfflineInterfaceContext = /*#__PURE__*/createContext(noopOfflineInterface);
-
 /**
  * Receives an OfflineInterface instance as a prop (presumably from the app
  * adapter) and provides it as context for other offline tools.
@@ -36,10 +35,8 @@ OfflineInterfaceProvider.propTypes = {
 };
 export function useOfflineInterface() {
   const offlineInterface = useContext(OfflineInterfaceContext);
-
   if (offlineInterface === undefined) {
     throw new Error('Offline interface context not found. If this app is using the app platform, make sure `pwa: { enabled: true }` is in d2.config.js. If this is not a platform app, make sure your app is wrapped with an app-runtime <Provider> or an <OfflineProvider> from app-service-offline.');
   }
-
   return offlineInterface;
 }

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

@@ -4,20 +4,17 @@ import { CacheableSectionProvider } from './cacheable-section-state';
 import { Dhis2ConnectionStatusProvider } from './dhis2-connection-status';
 import { OfflineInterfaceProvider } from './offline-interface';
 import { OnlineStatusMessageProvider } from './online-status-message';
-
 /** A context provider for all the relevant offline contexts */
 export function OfflineProvider(_ref) {
   let {
     offlineInterface,
     children
   } = _ref;
-
   // 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) {
     return /*#__PURE__*/React.createElement(React.Fragment, null, children);
   }
-
   return /*#__PURE__*/React.createElement(OfflineInterfaceProvider, {
     offlineInterface: offlineInterface
   }, /*#__PURE__*/React.createElement(Dhis2ConnectionStatusProvider, null, /*#__PURE__*/React.createElement(CacheableSectionProvider, null, /*#__PURE__*/React.createElement(OnlineStatusMessageProvider, null, children))));

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

@@ -3,7 +3,7 @@ import React, { useContext, useState } from 'react';
 // actually need the value don't have to rerender when the value changes:
 const OnlineStatusMessageValueContext = /*#__PURE__*/React.createContext(undefined);
 const SetOnlineStatusMessageContext = /*#__PURE__*/React.createContext(() => undefined);
-export const OnlineStatusMessageProvider = (_ref) => {
+export const OnlineStatusMessageProvider = _ref => {
   let {
     children
   } = _ref;
@@ -20,8 +20,9 @@ export const useOnlineStatusMessageValue = () => {
 };
 export const useSetOnlineStatusMessage = () => {
   return useContext(SetOnlineStatusMessageContext);
-}; // combination of both getter and setter (also provides backward compatability)
+};
 
+// combination of both getter and setter (also provides backward compatability)
 export const useOnlineStatusMessage = () => {
   const onlineStatusMessage = useOnlineStatusMessageValue();
   const setOnlineStatusMessage = useSetOnlineStatusMessage();

package/build/es/setupRTL.js

@@ -1 +1 @@
-import '@testing-library/jest-dom/extend-expect';
+import '@testing-library/jest-dom';

package/build/es/utils/__tests__/render-counter.test.js

@@ -4,9 +4,7 @@ import { RenderCounter, resetRenderCounts } from '../render-counter';
 const renderCounts = {};
 export const Rerenderer = () => {
   const [, setState] = React.useState(true);
-
   const toggleState = () => setState(prevState => !prevState);
-
   return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("button", {
     onClick: toggleState,
     role: "button"
@@ -19,7 +17,7 @@ afterEach(() => {
   resetRenderCounts(renderCounts);
 });
 it('increments the counter when rerendered', () => {
-  render( /*#__PURE__*/React.createElement(Rerenderer, null));
+  render(/*#__PURE__*/React.createElement(Rerenderer, null));
   const {
     getByTestId,
     getByRole
@@ -35,6 +33,6 @@ it('increments the counter when rerendered', () => {
   expect(getByTestId('rc1')).toHaveTextContent('3');
 });
 it('resets the render counter successfully', () => {
-  render( /*#__PURE__*/React.createElement(Rerenderer, null));
+  render(/*#__PURE__*/React.createElement(Rerenderer, null));
   expect(screen.getByTestId('rc1')).toHaveTextContent('1');
 });

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

@@ -1,14 +1,12 @@
 import React from 'react';
-export const RenderCounter = (_ref) => {
+export const RenderCounter = _ref => {
   let {
     id,
     countsObj
   } = _ref;
-
   if (!(id in countsObj)) {
     countsObj[id] = 0;
   }
-
   return /*#__PURE__*/React.createElement("div", {
     "data-testid": id
   }, ++countsObj[id]);

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

@@ -3,18 +3,17 @@ export const successfulRecordingMock = jest.fn().mockImplementation(async functi
     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();
 });
 export const errorRecordingMock = jest.fn().mockImplementation(function () {
@@ -22,15 +21,15 @@ export const errorRecordingMock = jest.fn().mockImplementation(function () {
     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();
 });
 export const failedMessageRecordingMock = jest.fn().mockRejectedValue(new Error('Failed message'));

package/build/types/lib/cacheable-section.d.ts

@@ -7,7 +7,7 @@ interface CacheableSectionStartRecordingOptions {
     onCompleted?: () => void;
     onError?: (err: Error) => void;
 }
-export declare type CacheableSectionStartRecording = (options?: CacheableSectionStartRecordingOptions) => Promise<any>;
+export type CacheableSectionStartRecording = (options?: CacheableSectionStartRecordingOptions) => Promise<any>;
 interface CacheableSectionControls {
     recordingState: RecordingState;
     startRecording: CacheableSectionStartRecording;

package/build/types/lib/dhis2-connection-status/dhis2-connection-status.d.ts

@@ -1,6 +1,6 @@
 import PropTypes from 'prop-types';
 import React from 'react';
-declare type AppName = string | undefined;
+type AppName = string | undefined;
 export declare const getLastConnectedKey: (appName?: AppName) => string;
 export interface Dhis2ConnectionStatus {
     isConnected: boolean;

package/build/types/lib/network-status.d.ts

@@ -1,4 +1,4 @@
-declare type milliseconds = number;
+type milliseconds = number;
 interface NetworkStatusOptions {
     debounceDelay?: milliseconds;
 }

package/build/types/lib/online-status-message.d.ts

@@ -1,5 +1,5 @@
 import React, { ReactElement, ReactNode } from 'react';
-declare type SetOnlineStatusMessage = (message: ReactNode) => void;
+type SetOnlineStatusMessage = (message: ReactNode) => void;
 export declare const OnlineStatusMessageProvider: ({ children, }: {
     children: ReactNode;
 }) => ReactElement;

package/build/types/types.d.ts

@@ -1,4 +1,4 @@
-export declare type RecordingState = 'default' | 'pending' | 'error' | 'recording';
+export type RecordingState = 'default' | 'pending' | 'error' | 'recording';
 export interface GlobalStateStoreMutation {
     (state: any): any;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@dhis2/app-service-offline",
     "description": "A runtime service for online/offline detection and offline caching",
-    "version": "3.11.3",
+    "version": "3.12.0-alpha.2",
     "main": "./build/cjs/index.js",
     "module": "./build/es/index.js",
     "types": "build/types/index.d.ts",
@@ -33,10 +33,10 @@
         "coverage": "yarn test --coverage"
     },
     "peerDependencies": {
-        "@dhis2/app-service-config": "3.11.3",
+        "@dhis2/app-service-config": "3.12.0-alpha.2",
         "prop-types": "^15.7.2",
-        "react": "^16.8.6",
-        "react-dom": "^16.8.6"
+        "react": "^16.8.6 || ^18",
+        "react-dom": "^16.8.6 || ^18"
     },
     "dependencies": {
         "lodash": "^4.17.21"