@dhis2/app-service-offline 3.8.0 → 3.9.1

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

@@ -0,0 +1 @@
+export { useDhis2ConnectionStatus, Dhis2ConnectionStatusProvider } from './dhis2-connection-status';

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

@@ -0,0 +1,36 @@
+/**
+ * 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 🤷‍♂️
+ */
+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 >= 3;
+
+    case 37:
+      return patch === undefined || patch >= 10;
+
+    default:
+      return minor >= 40;
+  }
+}

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

@@ -0,0 +1,73 @@
+import { isPingAvailable } from './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(isPingAvailable(version)).toBe(true);
+  });
+});
+test('unsupported server versions fail', () => {
+  unsupportedVersions.forEach(version => {
+    expect(isPingAvailable(version)).toBe(false);
+  });
+});

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

@@ -0,0 +1,199 @@
+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,
+    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);
+    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() {
+    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) {
+        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.
+        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() {
+    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
+    // (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() {
+    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!
+
+
+  clearTimeoutAndStart();
+  return {
+    clear,
+    pause,
+    resume,
+    invokeCallbackImmediately,
+    snooze,
+    reset
+  };
+}

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

@@ -0,0 +1,12 @@
+import { useConfig } from '@dhis2/app-service-config';
+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
+
+  const ping = useCallback(() => fetch(baseUrl + '/api/ping'), [baseUrl]);
+  return ping;
+}

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

@@ -7,7 +7,8 @@ import React, { useEffect, useCallback, useContext, useState } from 'react';
 // See more at https://github.com/amcgee/state-service-poc
 const identity = state => state;
 
-export const createStore = (initialState = {}) => {
+export const createStore = function () {
+  let initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   const subscriptions = new Set();
   let state = initialState;
   return {
@@ -31,17 +32,21 @@ const GlobalStateContext = /*#__PURE__*/React.createContext(createStore());
 
 const useGlobalStateStore = () => useContext(GlobalStateContext);
 
-export const GlobalStateProvider = ({
-  store,
-  children
-}) => /*#__PURE__*/React.createElement(GlobalStateContext.Provider, {
-  value: store
-}, children);
+export const GlobalStateProvider = (_ref) => {
+  let {
+    store,
+    children
+  } = _ref;
+  return /*#__PURE__*/React.createElement(GlobalStateContext.Provider, {
+    value: store
+  }, children);
+};
 GlobalStateProvider.propTypes = {
   children: PropTypes.node,
   store: PropTypes.shape({})
 };
-export const useGlobalState = (selector = identity) => {
+export const useGlobalState = function () {
+  let selector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : identity;
   const store = useGlobalStateStore();
   const [selectedState, setSelectedState] = useState(selector(store.getState()));
   useEffect(() => {
@@ -66,7 +71,7 @@ export const useGlobalState = (selector = identity) => {
 };
 export function useGlobalStateMutation(mutationCreator) {
   const store = useGlobalStateStore();
-  return useCallback((...args) => {
-    store.mutate(mutationCreator(...args));
+  return useCallback(function () {
+    store.mutate(mutationCreator(...arguments));
   }, [mutationCreator, store]);
 }

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

@@ -18,15 +18,18 @@ const lastOnlineKey = 'dhis2.lastOnline'; // TODO: Add option to periodically pi
  * @returns {Object} `{ online: boolean, offline: boolean, lastOnline: Date | null }`
  */
 
-export function useOnlineStatus(options = {}) {
+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 updateState = useCallback(debounce(({
-    type
-  }) => {
+  const updateState = useCallback(debounce((_ref) => {
+    let {
+      type
+    } = _ref;
+
     if (type === 'online') {
       setOnline(true);
     } else if (type === 'offline') {

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

@@ -3,6 +3,8 @@ import React, { createContext, useContext } from 'react';
 // 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
@@ -17,10 +19,11 @@ const OfflineInterfaceContext = /*#__PURE__*/createContext(noopOfflineInterface)
  * 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.
  */
-export function OfflineInterfaceProvider({
-  offlineInterface,
-  children
-}) {
+export function OfflineInterfaceProvider(_ref) {
+  let {
+    offlineInterface,
+    children
+  } = _ref;
   return /*#__PURE__*/React.createElement(OfflineInterfaceContext.Provider, {
     value: offlineInterface
   }, children);

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

@@ -1,14 +1,17 @@
 import PropTypes from 'prop-types';
 import React from 'react';
 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({
-  offlineInterface,
-  children
-}) {
+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) {
@@ -17,7 +20,7 @@ export function OfflineProvider({
 
   return /*#__PURE__*/React.createElement(OfflineInterfaceProvider, {
     offlineInterface: offlineInterface
-  }, /*#__PURE__*/React.createElement(CacheableSectionProvider, null, /*#__PURE__*/React.createElement(OnlineStatusMessageProvider, null, children)));
+  }, /*#__PURE__*/React.createElement(Dhis2ConnectionStatusProvider, null, /*#__PURE__*/React.createElement(CacheableSectionProvider, null, /*#__PURE__*/React.createElement(OnlineStatusMessageProvider, null, children))));
 }
 OfflineProvider.propTypes = {
   children: PropTypes.node,

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

@@ -14,9 +14,10 @@ export const useOnlineStatusMessage = () => {
     setOnlineStatusMessage
   };
 };
-export const OnlineStatusMessageProvider = ({
-  children
-}) => {
+export const OnlineStatusMessageProvider = (_ref) => {
+  let {
+    children
+  } = _ref;
   const [onlineStatusMessage, setOnlineStatusMessage] = useState();
   return /*#__PURE__*/React.createElement(OnlineStatusMessageContext.Provider, {
     value: {

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

@@ -1,8 +1,10 @@
 import React from 'react';
-export const RenderCounter = ({
-  id,
-  countsObj
-}) => {
+export const RenderCounter = (_ref) => {
+  let {
+    id,
+    countsObj
+  } = _ref;
+
   if (!(id in countsObj)) {
     countsObj[id] = 0;
   }

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

@@ -1,7 +1,9 @@
-export const successfulRecordingMock = jest.fn().mockImplementation(async ({
-  onStarted,
-  onCompleted
-} = {}) => {
+export 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);
@@ -15,10 +17,12 @@ export const successfulRecordingMock = jest.fn().mockImplementation(async ({
 
   return Promise.resolve();
 });
-export const errorRecordingMock = jest.fn().mockImplementation(({
-  onStarted,
-  onError
-} = {}) => {
+export 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);
@@ -32,7 +36,10 @@ export const errorRecordingMock = jest.fn().mockImplementation(({
 export const failedMessageRecordingMock = jest.fn().mockRejectedValue(new Error('Failed message'));
 export 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)
 };

package/build/types/index.d.ts

@@ -1,6 +1,7 @@
 export { OfflineProvider } from './lib/offline-provider';
 export { CacheableSection, useCacheableSection } from './lib/cacheable-section';
 export { useCachedSections } from './lib/cacheable-section-state';
-export { useOnlineStatus } from './lib/online-status';
+export { useNetworkStatus as useOnlineStatus } from './lib/network-status';
 export { useOnlineStatusMessage } from './lib/online-status-message';
 export { clearSensitiveCaches } from './lib/clear-sensitive-caches';
+export { useDhis2ConnectionStatus } from './lib/dhis2-connection-status';

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

@@ -0,0 +1,9 @@
+/**
+ * This can be used to log info if the `dhis2.debugConnectionStatus` value
+ * in localStorage is set to a truthy value during development.
+ * Set the value manually and refresh the page to see the logs.
+ *
+ * The behavior of the connection status can be quite hard to inspect without
+ * logs, but the logs are quite chatty and should be omitted normally.
+ */
+export declare function devDebugLog(...args: any[]): void;

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

@@ -0,0 +1,28 @@
+import PropTypes from 'prop-types';
+import React from 'react';
+declare type AppName = string | undefined;
+export declare const getLastConnectedKey: (appName?: AppName) => string;
+export interface Dhis2ConnectionStatus {
+    isConnected: boolean;
+    isDisconnected: boolean;
+    lastConnected: Date | null;
+}
+/**
+ * Provides a boolean indicating client's connection to the DHIS2 server,
+ * which is different from connection to the internet.
+ *
+ * The context provider subscribes to messages from the SW tracking successes
+ * and failures of requests to the DHIS2 server to determine connection status,
+ * and then will initiate periodic pings if there are no incidental requests in
+ * order to check the connection consistently
+ */
+export declare const Dhis2ConnectionStatusProvider: {
+    ({ children, }: {
+        children: React.ReactNode;
+    }): JSX.Element;
+    propTypes: {
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+    };
+};
+export declare const useDhis2ConnectionStatus: () => Dhis2ConnectionStatus;
+export {};

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

@@ -0,0 +1 @@
+export { useDhis2ConnectionStatus, Dhis2ConnectionStatusProvider, } from './dhis2-connection-status';

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

@@ -0,0 +1,14 @@
+import { Version } from '@dhis2/app-service-config';
+/**
+ * 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 🤷‍♂️
+ */
+export declare function isPingAvailable(serverVersion: Version): boolean;

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

@@ -0,0 +1,18 @@
+export declare const DEFAULT_INITIAL_DELAY_MS: number;
+export declare const DEFAULT_MAX_DELAY_MS: number;
+export declare const DEFAULT_INCREMENT_FACTOR = 1.5;
+export interface SmartInterval {
+    clear: () => void;
+    pause: () => void;
+    resume: () => void;
+    invokeCallbackImmediately: () => void;
+    snooze: () => void;
+    reset: () => void;
+}
+export default function createSmartInterval({ initialDelay, maxDelay, delayIncrementFactor, initialPauseValue, callback, }?: {
+    initialDelay?: number | undefined;
+    maxDelay?: number | undefined;
+    delayIncrementFactor?: number | undefined;
+    initialPauseValue?: boolean | undefined;
+    callback?: (() => void) | undefined;
+}): SmartInterval;

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

@@ -0,0 +1 @@
+export declare function usePingQuery(): () => Promise<any>;

package/build/types/lib/{online-status.d.ts → network-status.d.ts}

@@ -1,8 +1,8 @@
 declare type milliseconds = number;
-interface OnlineStatusOptions {
+interface NetworkStatusOptions {
     debounceDelay?: milliseconds;
 }
-interface OnlineStatus {
+export interface NetworkStatus {
     online: boolean;
     offline: boolean;
     lastOnline: Date | null;
@@ -21,5 +21,5 @@ interface OnlineStatus {
  * @param {Number} [options.debounceDelay] - Timeout delay to debounce updates, in ms
  * @returns {Object} `{ online: boolean, offline: boolean, lastOnline: Date | null }`
  */
-export declare function useOnlineStatus(options?: OnlineStatusOptions): OnlineStatus;
+export declare function useNetworkStatus(options?: NetworkStatusOptions): NetworkStatus;
 export {};

package/build/types/types.d.ts

@@ -34,6 +34,12 @@ export interface IndexedDBCachedSection {
 }
 export interface OfflineInterface {
     readonly pwaEnabled: boolean;
+    readonly latestIsConnected: boolean | null;
+    subscribeToDhis2ConnectionStatus: ({ onUpdate, }: {
+        onUpdate: ({ isConnected }: {
+            isConnected: boolean;
+        }) => void;
+    }) => () => void;
     startRecording: StartRecording;
     getCachedSections: () => Promise<IndexedDBCachedSection[]>;
     removeSection: (id: string) => Promise<boolean>;

package/build/types/utils/test-mocks.d.ts

@@ -4,7 +4,9 @@ export declare const errorRecordingMock: jest.Mock<any, any>;
 export declare const failedMessageRecordingMock: jest.Mock<any, any>;
 export declare const mockOfflineInterface: {
     pwaEnabled: boolean;
+    latestIsConnected: boolean;
     startRecording: jest.Mock<any, any>;
     getCachedSections: jest.Mock<any, any>;
     removeSection: jest.Mock<any, any>;
+    subscribeToDhis2ConnectionStatus: jest.Mock<any, any>;
 };