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

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

@@ -1,10 +1,10 @@
 // IndexedDB names; should be the same as in @dhis2/pwa
 export const SECTIONS_DB = 'sections-db';
-export const SECTIONS_STORE = 'sections-store'; // Non-sensitive caches that can be kept:
+export const SECTIONS_STORE = 'sections-store';
 
+// Non-sensitive caches that can be kept:
 const KEEPABLE_CACHES = [/^workbox-precache/ // precached static assets
 ];
-
 /*
  * Clears the 'sections-db' IndexedDB if it exists. Designed to avoid opening
  * a new DB if it doesn't exist yet. Firefox can't check if 'sections-db'
@@ -19,10 +19,8 @@ const clearDB = async dbName => {
     // and offline interface will handle discrepancies in PWA apps.
     return;
   }
-
   const dbs = await window.indexedDB.databases();
-
-  if (!dbs.some((_ref) => {
+  if (!dbs.some(_ref => {
     let {
       name
     } = _ref;
@@ -31,57 +29,51 @@ const clearDB = async dbName => {
     // Sections-db is not created; nothing to do here
     return;
   }
-
   return new Promise((resolve, reject) => {
     // IndexedDB fun:
     const openDBRequest = indexedDB.open(dbName);
-
     openDBRequest.onsuccess = e => {
       const db = e.target.result;
-      const tx = db.transaction(SECTIONS_STORE, 'readwrite'); // When the transaction completes is when the operation is done:
-
+      const tx = db.transaction(SECTIONS_STORE, 'readwrite');
+      // When the transaction completes is when the operation is done:
       tx.oncomplete = () => resolve();
-
       tx.onerror = e => reject(e.target.error);
-
       const os = tx.objectStore(SECTIONS_STORE);
       const clearReq = os.clear();
-
       clearReq.onerror = e => reject(e.target.error);
     };
-
     openDBRequest.onerror = e => {
       reject(e.target.error);
     };
   });
 };
+
 /**
  * Used to clear caches and 'sections-db' IndexedDB when a user logs out or a
  * different user logs in to prevent someone from accessing a different user's
  * caches. Should be able to be used in a non-PWA app.
  */
-
-
 export async function clearSensitiveCaches() {
   let dbName = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : SECTIONS_DB;
   console.debug('Clearing sensitive caches');
-  let cacheKeys; // caches.keys can fail in insecure contexts, see:
-  // https://developer.mozilla.org/en-US/docs/Web/API/CacheStorage
+  let cacheKeys;
 
+  // caches.keys can fail in insecure contexts, see:
+  // https://developer.mozilla.org/en-US/docs/Web/API/CacheStorage
   try {
     cacheKeys = await caches.keys();
   } catch (e) {
     // Return false since no caches have been cleared
     return false;
   }
-
-  return Promise.all([// (Resolves to 'false' because this can't detect if anything was deleted):
-  clearDB(dbName).then(() => false), // Remove caches if not in keepable list
+  return Promise.all([
+  // (Resolves to 'false' because this can't detect if anything was deleted):
+  clearDB(dbName).then(() => false),
+  // Remove caches if not in keepable list
   ...cacheKeys.map(key => {
     if (!KEEPABLE_CACHES.some(pattern => pattern.test(key))) {
       return caches.delete(key);
     }
-
     return false;
   })]).then(responses => {
     // Return true if any caches have been cleared

package/build/es/lib/dhis2-connection-status/dev-debug-log.js

@@ -1,8 +1,8 @@
 const shouldLog = localStorage.getItem('dhis2.debugConnectionStatus');
-
 if (shouldLog) {
   console.log('Logging for dhis2ConnectionStatus is enabled. Remove the `dhis2.debugConnectionStatus` item in localStorage to disable logging.');
 }
+
 /**
  * This can be used to log info if the `dhis2.debugConnectionStatus` value
  * in localStorage is set to a truthy value during development.
@@ -11,8 +11,6 @@ if (shouldLog) {
  * 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 function devDebugLog() {
   if (shouldLog) {
     console.log(...arguments);

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

@@ -6,32 +6,30 @@ import { useOfflineInterface } from '../offline-interface';
 import { devDebugLog } from './dev-debug-log';
 import { isPingAvailable } from './is-ping-available';
 import createSmartInterval from './smart-interval';
-import { usePingQuery } from './use-ping-query'; // Utils for saving 'last connected' datetime in local storage
+import { usePingQuery } from './use-ping-query';
 
+// Utils for saving 'last connected' datetime in local storage
 const lastConnectedKey = 'dhis2.lastConnected';
 export const getLastConnectedKey = appName => appName ? `${lastConnectedKey}.${appName}` : lastConnectedKey;
-
 const updateLastConnected = appName => {
   // use Date.now() because it's easier to mock for easier unit testing
   const now = new Date(Date.now());
   localStorage.setItem(getLastConnectedKey(appName), now.toUTCString());
   return now;
 };
-
 const getLastConnected = appName => {
   const lastConnected = localStorage.getItem(getLastConnectedKey(appName));
   return lastConnected ? new Date(lastConnected) : null;
 };
-
 const clearLastConnected = appName => {
   localStorage.removeItem(getLastConnectedKey(appName));
 };
-
 const Dhis2ConnectionStatusContext = /*#__PURE__*/React.createContext({
   isConnected: true,
   isDisconnected: false,
   lastConnected: null
 });
+
 /**
  * Provides a boolean indicating client's connection to the DHIS2 server,
  * which is different from connection to the internet.
@@ -41,8 +39,7 @@ const Dhis2ConnectionStatusContext = /*#__PURE__*/React.createContext({
  * and then will initiate periodic pings if there are no incidental requests in
  * order to check the connection consistently
  */
-
-export const Dhis2ConnectionStatusProvider = (_ref) => {
+export const Dhis2ConnectionStatusProvider = _ref => {
   let {
     children
   } = _ref;
@@ -50,21 +47,21 @@ export const Dhis2ConnectionStatusProvider = (_ref) => {
   const {
     appName,
     serverVersion
-  } = useConfig(); // The offline interface persists the latest update from the SW so that
+  } = useConfig();
+  // The offline interface persists the latest update from the SW so that
   // this hook can initialize to an accurate value. The App Adapter in the
   // platform waits for this value to be populated before rendering the
   // the App Runtime provider (including this), but if that is not done,
   // `latestIsConnected` may be `null` depending on the outcome of race
   // conditions between the SW and the React component tree.
-
   const [isConnected, setIsConnected] = useState(offlineInterface.latestIsConnected);
   const ping = usePingQuery();
   const smartIntervalRef = useRef(null);
+
   /**
    * Update state, reset ping backoff if changed, and update
    * the lastConnected value in localStorage
    */
-
   const updateConnectedState = useCallback(newIsConnected => {
     // use 'set' with a function as param to get latest isConnected
     // without needing it as a dependency for useCallback
@@ -73,13 +70,10 @@ export const Dhis2ConnectionStatusProvider = (_ref) => {
         prevIsConnected,
         newIsConnected
       });
-
       if (newIsConnected !== prevIsConnected) {
         var _smartIntervalRef$cur;
-
         // if value changed, reset ping interval to initial delay
         (_smartIntervalRef$cur = smartIntervalRef.current) === null || _smartIntervalRef$cur === void 0 ? void 0 : _smartIntervalRef$cur.reset();
-
         if (newIsConnected) {
           // Need to clear this here so it doesn't affect another
           // session that starts while offline
@@ -88,15 +82,15 @@ export const Dhis2ConnectionStatusProvider = (_ref) => {
           updateLastConnected(appName);
         }
       }
-
       return newIsConnected;
     });
-  }, [appName]); // Note that the SW is configured to not cache ping requests and won't
+  }, [appName]);
+
+  // Note that the SW is configured to not cache ping requests and won't
   // trigger `handleChange` below to avoid redundant signals. This also
   // helps to detect the connectivity status when the SW is not available
   // for some reason (maybe private browsing, first installation, or
   // insecure browser context)
-
   const pingAndHandleStatus = useCallback(() => {
     return ping().then(() => {
       // Ping is successful; set 'connected'
@@ -106,16 +100,16 @@ export const Dhis2ConnectionStatusProvider = (_ref) => {
       updateConnectedState(false);
     });
   }, [ping, updateConnectedState]);
-  /** Called when SW reports updates from incidental network traffic */
 
-  const onUpdate = useCallback((_ref2) => {
+  /** Called when SW reports updates from incidental network traffic */
+  const onUpdate = useCallback(_ref2 => {
     var _smartIntervalRef$cur2;
-
     let {
       isConnected: newIsConnected
     } = _ref2;
-    devDebugLog('[D2CS] handling update from sw'); // Snooze ping timer to reduce pings since we know state from SW
+    devDebugLog('[D2CS] handling update from sw');
 
+    // Snooze ping timer to reduce pings since we know state from SW
     (_smartIntervalRef$cur2 = smartIntervalRef.current) === null || _smartIntervalRef$cur2 === void 0 ? void 0 : _smartIntervalRef$cur2.snooze();
     updateConnectedState(newIsConnected);
   }, [updateConnectedState]);
@@ -124,26 +118,22 @@ export const Dhis2ConnectionStatusProvider = (_ref) => {
     // pinging with the smart interval. Just use the service worker
     if (!serverVersion || !isPingAvailable(serverVersion)) {
       return;
-    } // Only create the smart interval once
-
+    }
 
+    // Only create the smart interval once
     const smartInterval = createSmartInterval({
       // don't ping if window isn't focused or visible
       initialPauseValue: !document.hasFocus() || document.visibilityState !== 'visible',
       callback: pingAndHandleStatus
     });
     smartIntervalRef.current = smartInterval;
-
     const handleBlur = () => smartInterval.pause();
-
-    const handleFocus = () => smartInterval.resume(); // Pinging when going offline should be low/no-cost in both online and
+    const handleFocus = () => smartInterval.resume();
+    // Pinging when going offline should be low/no-cost in both online and
     // local servers
-
-
-    const handleOffline = () => smartInterval.invokeCallbackImmediately(); // Pinging when going online has a cost but improves responsiveness of
+    const handleOffline = () => smartInterval.invokeCallbackImmediately();
+    // Pinging when going online has a cost but improves responsiveness of
     // the connection status -- only do it once every 15 seconds at most
-
-
     const handleOnline = throttle(() => smartInterval.invokeCallbackImmediately(), 15000);
     window.addEventListener('blur', handleBlur);
     window.addEventListener('focus', handleFocus);
@@ -153,8 +143,9 @@ export const Dhis2ConnectionStatusProvider = (_ref) => {
       window.removeEventListener('blur', handleBlur);
       window.removeEventListener('focus', handleFocus);
       window.removeEventListener('offline', handleOffline);
-      window.removeEventListener('online', handleOnline); // clean up smart interval and throttled function
+      window.removeEventListener('online', handleOnline);
 
+      // clean up smart interval and throttled function
       smartInterval.clear();
       handleOnline.cancel();
     };
@@ -162,22 +153,21 @@ export const Dhis2ConnectionStatusProvider = (_ref) => {
   useEffect(() => {
     if (!offlineInterface.subscribeToDhis2ConnectionStatus) {
       var _smartIntervalRef$cur3;
-
       // Missing this functionality from the offline interface --
       // use a ping on startup to get the status
       (_smartIntervalRef$cur3 = smartIntervalRef.current) === null || _smartIntervalRef$cur3 === void 0 ? void 0 : _smartIntervalRef$cur3.invokeCallbackImmediately();
       console.warn('Please upgrade to @dhis2/cli-app-scripts@>10.3.8 for full connection status features');
       return;
     }
-
     const unsubscribe = offlineInterface.subscribeToDhis2ConnectionStatus({
       onUpdate
     });
     return () => {
       unsubscribe();
     };
-  }, [offlineInterface, onUpdate]); // Memoize this value to prevent unnecessary rerenders of context provider
+  }, [offlineInterface, onUpdate]);
 
+  // Memoize this value to prevent unnecessary rerenders of context provider
   const contextValue = useMemo(() => {
     // in the unlikely circumstance that offlineInterface.latestIsConnected
     // is `null` or `undefined` when this initializes, fail safe by defaulting to
@@ -186,7 +176,8 @@ export const Dhis2ConnectionStatusProvider = (_ref) => {
     return {
       isConnected: validatedIsConnected,
       isDisconnected: !validatedIsConnected,
-      lastConnected: validatedIsConnected ? null : // Only evaluate if disconnected, since local storage
+      lastConnected: validatedIsConnected ? null :
+      // Only evaluate if disconnected, since local storage
       // is synchronous and disk-based.
       // If lastConnected is not set in localStorage though, set it.
       // (relevant on startup)
@@ -202,10 +193,8 @@ Dhis2ConnectionStatusProvider.propTypes = {
 };
 export const useDhis2ConnectionStatus = () => {
   const context = useContext(Dhis2ConnectionStatusContext);
-
   if (!context) {
     throw new Error('useDhis2ConnectionStatus must be used within a Dhis2ConnectionStatus provider');
   }
-
   return context;
 };