@dhis2/app-service-offline 3.8.0 → 3.9.1

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

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Dhis2ConnectionStatusProvider", {
+  enumerable: true,
+  get: function () {
+    return _dhis2ConnectionStatus.Dhis2ConnectionStatusProvider;
+  }
+});
+Object.defineProperty(exports, "useDhis2ConnectionStatus", {
+  enumerable: true,
+  get: function () {
+    return _dhis2ConnectionStatus.useDhis2ConnectionStatus;
+  }
+});
+
+var _dhis2ConnectionStatus = require("./dhis2-connection-status");

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

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isPingAvailable = isPingAvailable;
+
+/**
+ * Checks the server version to see if the /api/ping endpoint is available for
+ * this version.
+ *
+ * The endpoint was released for versions 2.37.10, 2.38.3, 2.39.2, and 2.40.0
+ * (see DHIS2-14531). All versions below that are considered unsupported
+ *
+ * If the patchVersion is undefined, it's assumed to be a dev server that's
+ * newer than the fix versions listed above
+ *
+ * Major versions above 2 aren't supported 🤷‍♂️
+ */
+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 >= 3;
+
+    case 37:
+      return patch === undefined || patch >= 10;
+
+    default:
+      return minor >= 40;
+  }
+}

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

@@ -0,0 +1,76 @@
+"use strict";
+
+var _isPingAvailable = require("./is-ping-available");
+
+const fixedVersions = [{
+  full: 'unimportant',
+  major: 2,
+  minor: 40,
+  patch: 0
+}, {
+  full: 'unimportant',
+  major: 2,
+  minor: 39,
+  patch: 2
+}, {
+  full: 'unimportant',
+  major: 2,
+  minor: 38,
+  patch: 3
+}, {
+  full: 'unimportant',
+  major: 2,
+  minor: 37,
+  patch: 10
+}, {
+  full: 'unimportant',
+  major: 2,
+  minor: 40,
+  tag: 'SNAPSHOT'
+}, {
+  full: 'unimportant',
+  major: 2,
+  minor: 3291,
+  patch: 0
+}];
+const unsupportedVersions = [{
+  full: 'unimportant',
+  major: 2,
+  minor: 39,
+  patch: 1
+}, {
+  full: 'unimportant',
+  major: 2,
+  minor: 38,
+  patch: 2
+}, {
+  full: 'unimportant',
+  major: 2,
+  minor: 37,
+  patch: 9
+}, {
+  full: 'unimportant',
+  major: 2,
+  minor: 36,
+  patch: 12
+}, {
+  full: 'unimportant',
+  major: 2,
+  minor: 35,
+  patch: 0
+}, {
+  full: 'unimportant',
+  major: 2,
+  minor: 0,
+  patch: 0
+}];
+test('supported server versions pass', () => {
+  fixedVersions.forEach(version => {
+    expect((0, _isPingAvailable.isPingAvailable)(version)).toBe(true);
+  });
+});
+test('unsupported server versions fail', () => {
+  unsupportedVersions.forEach(version => {
+    expect((0, _isPingAvailable.isPingAvailable)(version)).toBe(false);
+  });
+});

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

@@ -0,0 +1,211 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DEFAULT_MAX_DELAY_MS = exports.DEFAULT_INITIAL_DELAY_MS = exports.DEFAULT_INCREMENT_FACTOR = void 0;
+exports.default = createSmartInterval;
+
+var _devDebugLog = require("./dev-debug-log");
+
+// Exported for tests
+const DEFAULT_INITIAL_DELAY_MS = 1000 * 30; // 30 sec
+
+exports.DEFAULT_INITIAL_DELAY_MS = DEFAULT_INITIAL_DELAY_MS;
+const DEFAULT_MAX_DELAY_MS = 1000 * 60 * 5; // 5 min
+
+exports.DEFAULT_MAX_DELAY_MS = DEFAULT_MAX_DELAY_MS;
+const DEFAULT_INCREMENT_FACTOR = 1.5;
+exports.DEFAULT_INCREMENT_FACTOR = DEFAULT_INCREMENT_FACTOR;
+
+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] : {};
+  const state = {
+    paused: initialPauseValue,
+    delay: initialDelay,
+    // Timeout types are weird; this dummy timeout helps fix them:
+    // (named to help debugging in tests)
+    timeout: setTimeout(function dummyTimeout() {
+      return;
+    }, 0),
+    standbyCallback: null
+  };
+  /** Increment delay by the increment factor, up to a max value */
+
+  function incrementDelay() {
+    const newDelay = Math.min(state.delay * delayIncrementFactor, maxDelay);
+    (0, _devDebugLog.devDebugLog)('[SI] incrementing delay', {
+      prev: state.delay,
+      new: newDelay
+    });
+    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() {
+    (0, _devDebugLog.devDebugLog)('[SI] clearing and starting timeout', {
+      delay: state.delay
+    }); // Prevent parallel timeouts from occuring
+    // (weird note: `if (this.timeout) { clearTimeout(this.timeout) }`
+    // does NOT work for some reason)
+
+    clearTimeout(state.timeout); // 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) {
+        (0, _devDebugLog.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
+
+      clearTimeoutAndStart();
+    }, state.delay);
+  }
+  /** 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
+   * (unless the timer fully elapses while this interval is paused).
+   *
+   * If the interval is 'paused', it will not invoke the callback immediately,
+   * but enter a 'partial standby', which will invoke the callback upon
+   * resuming, but without incrementing the delay. If the regular timeout
+   * elapses while paused, the regular standby is entered, overwriting this
+   * partial standby.
+   */
+
+
+  function invokeCallbackImmediately() {
+    if (state.paused) {
+      if (state.standbyCallback === null) {
+        // If there is not an existing standbyCallback,
+        // set one to be called upon `resume()`
+        // (but don't overwrite a previous callback).
+        // See setTimeout call above too.
+        // The timed out function set in `clearTimeoutAndStart` may
+        // overwrite this callback if the timer elapses, so that the
+        // timeout delay gets incremented appropriately.
+        (0, _devDebugLog.devDebugLog)('[SI] entering standby without timer increment');
+
+        state.standbyCallback = () => {
+          // Invoke callback and start timer without incrementing
+          callback();
+          clearTimeoutAndStart();
+        };
+      } // Skip rest of execution while paused
+
+
+      return;
+    } // Invoke callback and start timer without incrementing
+
+
+    callback();
+    clearTimeoutAndStart();
+  }
+  /**
+   * Sets a 'paused' flag (doesn't yet stop the timer):
+   *
+   * If the main timer elapses or `invokeCallbackImmediately` is called
+   * while the interval is paused, the timer will not be started again.
+   * Instead, a callback function will be saved that will be called when
+   * `resume()` is called (see its definition below)
+   *
+   * This decreases execution activity while 'paused'
+   */
+
+
+  function pause() {
+    (0, _devDebugLog.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() {
+    (0, _devDebugLog.devDebugLog)('[SI] resuming', {
+      standbyCb: state.standbyCallback
+    }); // 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 = null;
+    }
+  }
+  /**
+   * Restart the timer to the next callback invocation, using the current
+   * delay
+   *
+   * Expected to be called to delay a ping in response to incidental network
+   * traffic, for example
+   */
+
+
+  function snooze() {
+    (0, _devDebugLog.devDebugLog)('[SI] snoozing timeout');
+    clearTimeoutAndStart();
+  }
+  /**
+   * Cancels the current timeout and starts a new one with the initial delay
+   */
+
+
+  function reset() {
+    (0, _devDebugLog.devDebugLog)('[SI] resetting interval from beginning');
+    state.delay = initialDelay;
+    clearTimeoutAndStart();
+  } // Start the timer!
+
+
+  clearTimeoutAndStart();
+  return {
+    clear,
+    pause,
+    resume,
+    invokeCallbackImmediately,
+    snooze,
+    reset
+  };
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePingQuery = usePingQuery;
+
+var _appServiceConfig = require("@dhis2/app-service-config");
+
+var _react = require("react");
+
+// This function has a separate file for easier mocking
+function usePingQuery() {
+  const {
+    baseUrl
+  } = (0, _appServiceConfig.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 = (0, _react.useCallback)(() => fetch(baseUrl + '/api/ping'), [baseUrl]);
+  return ping;
+}

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

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.useGlobalState = exports.createStore = exports.GlobalStateProvider = void 0;
 exports.useGlobalStateMutation = useGlobalStateMutation;
-exports.useGlobalState = exports.GlobalStateProvider = exports.createStore = void 0;
 
 var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
 
@@ -23,7 +23,8 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 // See more at https://github.com/amcgee/state-service-poc
 const identity = state => state;
 
-const createStore = (initialState = {}) => {
+const createStore = function () {
+  let initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   const subscriptions = new Set();
   let state = initialState;
   return {
@@ -50,12 +51,15 @@ const GlobalStateContext = /*#__PURE__*/_react.default.createContext(createStore
 
 const useGlobalStateStore = () => (0, _react.useContext)(GlobalStateContext);
 
-const GlobalStateProvider = ({
-  store,
-  children
-}) => /*#__PURE__*/_react.default.createElement(GlobalStateContext.Provider, {
-  value: store
-}, children);
+const GlobalStateProvider = (_ref) => {
+  let {
+    store,
+    children
+  } = _ref;
+  return /*#__PURE__*/_react.default.createElement(GlobalStateContext.Provider, {
+    value: store
+  }, children);
+};
 
 exports.GlobalStateProvider = GlobalStateProvider;
 GlobalStateProvider.propTypes = {
@@ -63,7 +67,8 @@ GlobalStateProvider.propTypes = {
   store: _propTypes.default.shape({})
 };
 
-const useGlobalState = (selector = identity) => {
+const useGlobalState = function () {
+  let selector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : identity;
   const store = useGlobalStateStore();
   const [selectedState, setSelectedState] = (0, _react.useState)(selector(store.getState()));
   (0, _react.useEffect)(() => {
@@ -91,7 +96,7 @@ exports.useGlobalState = useGlobalState;
 
 function useGlobalStateMutation(mutationCreator) {
   const store = useGlobalStateStore();
-  return (0, _react.useCallback)((...args) => {
-    store.mutate(mutationCreator(...args));
+  return (0, _react.useCallback)(function () {
+    store.mutate(mutationCreator(...arguments));
   }, [mutationCreator, store]);
 }

package/build/cjs/lib/{online-status.js → network-status.js}

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.useOnlineStatus = useOnlineStatus;
+exports.useNetworkStatus = useNetworkStatus;
 
 var _debounce = _interopRequireDefault(require("lodash/debounce"));
 
@@ -29,15 +29,18 @@ const lastOnlineKey = 'dhis2.lastOnline'; // TODO: Add option to periodically pi
  * @returns {Object} `{ online: boolean, offline: boolean, lastOnline: Date | null }`
  */
 
-function useOnlineStatus(options = {}) {
+function useNetworkStatus() {
   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)(({
-    type
-  }) => {
+  const updateState = (0, _react.useCallback)((0, _debounce.default)((_ref) => {
+    let {
+      type
+    } = _ref;
+
     if (type === 'online') {
       setOnline(true);
     } else if (type === 'offline') {

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

@@ -19,6 +19,8 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 // This is to prevent 'offlineInterface could be null' type-checking errors
 const noopOfflineInterface = {
   pwaEnabled: false,
+  latestIsConnected: false,
+  subscribeToDhis2ConnectionStatus: () => () => undefined,
   startRecording: async () => undefined,
   getCachedSections: async () => [],
   removeSection: async () => false
@@ -33,10 +35,11 @@ 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({
-  offlineInterface,
-  children
-}) {
+function OfflineInterfaceProvider(_ref) {
+  let {
+    offlineInterface,
+    children
+  } = _ref;
   return /*#__PURE__*/_react.default.createElement(OfflineInterfaceContext.Provider, {
     value: offlineInterface
   }, children);

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

@@ -11,6 +11,8 @@ var _react = _interopRequireDefault(require("react"));
 
 var _cacheableSectionState = require("./cacheable-section-state");
 
+var _dhis2ConnectionStatus = require("./dhis2-connection-status");
+
 var _offlineInterface = require("./offline-interface");
 
 var _onlineStatusMessage = require("./online-status-message");
@@ -18,10 +20,12 @@ var _onlineStatusMessage = require("./online-status-message");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 /** A context provider for all the relevant offline contexts */
-function OfflineProvider({
-  offlineInterface,
-  children
-}) {
+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) {
@@ -30,7 +34,7 @@ function OfflineProvider({
 
   return /*#__PURE__*/_react.default.createElement(_offlineInterface.OfflineInterfaceProvider, {
     offlineInterface: offlineInterface
-  }, /*#__PURE__*/_react.default.createElement(_cacheableSectionState.CacheableSectionProvider, null, /*#__PURE__*/_react.default.createElement(_onlineStatusMessage.OnlineStatusMessageProvider, null, children)));
+  }, /*#__PURE__*/_react.default.createElement(_dhis2ConnectionStatus.Dhis2ConnectionStatusProvider, null, /*#__PURE__*/_react.default.createElement(_cacheableSectionState.CacheableSectionProvider, null, /*#__PURE__*/_react.default.createElement(_onlineStatusMessage.OnlineStatusMessageProvider, null, children))));
 }
 
 OfflineProvider.propTypes = {

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.OnlineStatusMessageProvider = exports.useOnlineStatusMessage = void 0;
+exports.useOnlineStatusMessage = exports.OnlineStatusMessageProvider = void 0;
 
 var _react = _interopRequireWildcard(require("react"));
 
@@ -31,9 +31,10 @@ const useOnlineStatusMessage = () => {
 
 exports.useOnlineStatusMessage = useOnlineStatusMessage;
 
-const OnlineStatusMessageProvider = ({
-  children
-}) => {
+const OnlineStatusMessageProvider = (_ref) => {
+  let {
+    children
+  } = _ref;
   const [onlineStatusMessage, setOnlineStatusMessage] = (0, _react.useState)();
   return /*#__PURE__*/_react.default.createElement(OnlineStatusMessageContext.Provider, {
     value: {

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

@@ -9,10 +9,12 @@ var _react = _interopRequireDefault(require("react"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-const RenderCounter = ({
-  id,
-  countsObj
-}) => {
+const RenderCounter = (_ref) => {
+  let {
+    id,
+    countsObj
+  } = _ref;
+
   if (!(id in countsObj)) {
     countsObj[id] = 0;
   }

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

@@ -3,11 +3,13 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.mockOfflineInterface = exports.failedMessageRecordingMock = exports.errorRecordingMock = exports.successfulRecordingMock = void 0;
-const successfulRecordingMock = jest.fn().mockImplementation(async ({
-  onStarted,
-  onCompleted
-} = {}) => {
+exports.successfulRecordingMock = exports.mockOfflineInterface = exports.failedMessageRecordingMock = exports.errorRecordingMock = void 0;
+const 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);
@@ -22,10 +24,12 @@ const successfulRecordingMock = jest.fn().mockImplementation(async ({
   return Promise.resolve();
 });
 exports.successfulRecordingMock = successfulRecordingMock;
-const errorRecordingMock = jest.fn().mockImplementation(({
-  onStarted,
-  onError
-} = {}) => {
+const 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);
@@ -41,8 +45,11 @@ const failedMessageRecordingMock = jest.fn().mockRejectedValue(new Error('Failed
 exports.failedMessageRecordingMock = failedMessageRecordingMock;
 const mockOfflineInterface = {
   pwaEnabled: true,
+  latestIsConnected: true,
   startRecording: successfulRecordingMock,
   getCachedSections: jest.fn().mockResolvedValue([]),
-  removeSection: jest.fn().mockResolvedValue(true)
+  removeSection: jest.fn().mockResolvedValue(true),
+  // returns an unsubscribe function
+  subscribeToDhis2ConnectionStatus: jest.fn().mockReturnValue(() => undefined)
 };
 exports.mockOfflineInterface = mockOfflineInterface;