chore(datafile manager): Fix ESLint warnings & errors, apply Prettier formatting

packages/datafile-manager/.eslintrc.js

@@ -23,5 +23,7 @@ module.exports = {
     '@typescript-eslint/ban-ts-ignore': 'off',
     '@typescript-eslint/camelcase': 'off',
     '@typescript-eslint/no-empty-function': 'off',
+    '@typescript-eslint/no-explicit-any': 'off',
+    '@typescript-eslint/no-non-null-assertion': 'off'
   },
 };

packages/datafile-manager/src/backoffController.ts

@@ -14,33 +14,33 @@
  * limitations under the License.
  */
 
-import { BACKOFF_BASE_WAIT_SECONDS_BY_ERROR_COUNT } from './config'
+import { BACKOFF_BASE_WAIT_SECONDS_BY_ERROR_COUNT } from './config';
 
-function randomMilliseconds() {
-  return Math.round(Math.random() * 1000)
+function randomMilliseconds(): number {
+  return Math.round(Math.random() * 1000);
 }
 
 export default class BackoffController {
-  private errorCount = 0
+  private errorCount = 0;
 
   getDelay(): number {
     if (this.errorCount === 0) {
-      return 0
+      return 0;
     }
     const baseWaitSeconds =
       BACKOFF_BASE_WAIT_SECONDS_BY_ERROR_COUNT[
         Math.min(BACKOFF_BASE_WAIT_SECONDS_BY_ERROR_COUNT.length - 1, this.errorCount)
-      ]
-    return baseWaitSeconds * 1000 + randomMilliseconds()
+      ];
+    return baseWaitSeconds * 1000 + randomMilliseconds();
   }
 
   countError(): void {
     if (this.errorCount < BACKOFF_BASE_WAIT_SECONDS_BY_ERROR_COUNT.length - 1) {
-      this.errorCount++
+      this.errorCount++;
     }
   }
 
   reset(): void {
-    this.errorCount = 0
+    this.errorCount = 0;
   }
 }

packages/datafile-manager/src/browserDatafileManager.ts

@@ -14,19 +14,19 @@
  * limitations under the License.
  */
 
-import { makeGetRequest } from './browserRequest'
-import HttpPollingDatafileManager from './httpPollingDatafileManager'
+import { makeGetRequest } from './browserRequest';
+import HttpPollingDatafileManager from './httpPollingDatafileManager';
 import { Headers, AbortableRequest } from './http';
 import { DatafileManagerConfig } from './datafileManager';
 
 export default class BrowserDatafileManager extends HttpPollingDatafileManager {
   protected makeGetRequest(reqUrl: string, headers: Headers): AbortableRequest {
-    return makeGetRequest(reqUrl, headers)
+    return makeGetRequest(reqUrl, headers);
   }
 
   protected getConfigDefaults(): Partial<DatafileManagerConfig> {
     return {
       autoUpdate: false,
-    }
+    };
   }
 }

packages/datafile-manager/src/browserRequest.ts

@@ -14,83 +14,83 @@
  * limitations under the License.
  */
 
-import { AbortableRequest, Response, Headers } from './http'
-import { REQUEST_TIMEOUT_MS } from './config'
-import { getLogger } from '@optimizely/js-sdk-logging'
+import { AbortableRequest, Response, Headers } from './http';
+import { REQUEST_TIMEOUT_MS } from './config';
+import { getLogger } from '@optimizely/js-sdk-logging';
 
-const logger = getLogger('DatafileManager')
+const logger = getLogger('DatafileManager');
 
-const GET_METHOD = 'GET'
-const READY_STATE_DONE = 4
+const GET_METHOD = 'GET';
+const READY_STATE_DONE = 4;
 
 function parseHeadersFromXhr(req: XMLHttpRequest): Headers {
-  const allHeadersString = req.getAllResponseHeaders()
+  const allHeadersString = req.getAllResponseHeaders();
 
   if (allHeadersString === null) {
-    return {}
+    return {};
   }
 
-  const headerLines = allHeadersString.split('\r\n')
-  const headers: Headers = {}
+  const headerLines = allHeadersString.split('\r\n');
+  const headers: Headers = {};
   headerLines.forEach(headerLine => {
-    const separatorIndex = headerLine.indexOf(': ')
+    const separatorIndex = headerLine.indexOf(': ');
     if (separatorIndex > -1) {
-      const headerName = headerLine.slice(0, separatorIndex)
-      const headerValue = headerLine.slice(separatorIndex + 2)
+      const headerName = headerLine.slice(0, separatorIndex);
+      const headerValue = headerLine.slice(separatorIndex + 2);
       if (headerValue.length > 0) {
-        headers[headerName] = headerValue
+        headers[headerName] = headerValue;
       }
     }
-  })
-  return headers
+  });
+  return headers;
 }
 
 function setHeadersInXhr(headers: Headers, req: XMLHttpRequest): void {
   Object.keys(headers).forEach(headerName => {
-    const header = headers[headerName]
-    req.setRequestHeader(headerName, header!)
-  })
+    const header = headers[headerName];
+    req.setRequestHeader(headerName, header!);
+  });
 }
 
 export function makeGetRequest(reqUrl: string, headers: Headers): AbortableRequest {
-  const req = new XMLHttpRequest()
+  const req = new XMLHttpRequest();
 
   const responsePromise: Promise<Response> = new Promise((resolve, reject) => {
-    req.open(GET_METHOD, reqUrl, true)
+    req.open(GET_METHOD, reqUrl, true);
 
-    setHeadersInXhr(headers, req)
+    setHeadersInXhr(headers, req);
 
-    req.onreadystatechange = () => {
+    req.onreadystatechange = (): void => {
       if (req.readyState === READY_STATE_DONE) {
-        const statusCode = req.status
+        const statusCode = req.status;
         if (statusCode === 0) {
-          reject(new Error('Request error'))
-          return
+          reject(new Error('Request error'));
+          return;
         }
 
-        const headers = parseHeadersFromXhr(req)
+        const headers = parseHeadersFromXhr(req);
         const resp: Response = {
           statusCode: req.status,
           body: req.responseText,
           headers,
-        }
-        resolve(resp)
+        };
+        resolve(resp);
       }
-    }
+    };
 
-    req.timeout = REQUEST_TIMEOUT_MS
+    req.timeout = REQUEST_TIMEOUT_MS;
 
-    req.ontimeout = () => {
-      logger.error('Request timed out')
-    }
+    req.ontimeout = (): void => {
+      logger.error('Request timed out');
+    };
 
-    req.send()
-  })
+    req.send();
+  });
 
   return {
     responsePromise,
-    abort() {
-      req.abort()
+    abort(): void {
+      req.abort();
     },
-  }
+  };
 }

packages/datafile-manager/src/config.ts

@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-export const DEFAULT_UPDATE_INTERVAL = 5 * 60 * 1000 // 5 minutes
+export const DEFAULT_UPDATE_INTERVAL = 5 * 60 * 1000; // 5 minutes
 
-export const MIN_UPDATE_INTERVAL = 1000
+export const MIN_UPDATE_INTERVAL = 1000;
 
-export const DEFAULT_URL_TEMPLATE = `https://cdn.optimizely.com/datafiles/%s.json`
+export const DEFAULT_URL_TEMPLATE = `https://cdn.optimizely.com/datafiles/%s.json`;
 
-export const BACKOFF_BASE_WAIT_SECONDS_BY_ERROR_COUNT = [0, 8, 16, 32, 64, 128, 256, 512]
+export const BACKOFF_BASE_WAIT_SECONDS_BY_ERROR_COUNT = [0, 8, 16, 32, 64, 128, 256, 512];
 
-export const REQUEST_TIMEOUT_MS = 60 * 1000 // 1 minute
+export const REQUEST_TIMEOUT_MS = 60 * 1000; // 1 minute

packages/datafile-manager/src/datafileManager.ts

@@ -13,34 +13,34 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import PersistentKeyValueCache from './persistentKeyValueCache'
+import PersistentKeyValueCache from './persistentKeyValueCache';
 
 export interface DatafileUpdate {
-  datafile: object
+  datafile: object;
 }
 
 export interface DatafileUpdateListener {
-  (datafileUpdate: DatafileUpdate): void
+  (datafileUpdate: DatafileUpdate): void;
 }
 
 // TODO: Replace this with the one from js-sdk-models
 interface Managed {
-  start(): void
+  start(): void;
 
-  stop(): Promise<any>
+  stop(): Promise<any>;
 }
 
 export interface DatafileManager extends Managed {
-  get: () => object | null
-  on: (eventName: string, listener: DatafileUpdateListener) => () => void
-  onReady: () => Promise<void>
+  get: () => object | null;
+  on: (eventName: string, listener: DatafileUpdateListener) => () => void;
+  onReady: () => Promise<void>;
 }
 
 export interface DatafileManagerConfig {
-  autoUpdate?: boolean
-  datafile?: object
-  sdkKey: string
-  updateInterval?: number
-  urlTemplate?: string
-  cache?: PersistentKeyValueCache
+  autoUpdate?: boolean;
+  datafile?: object;
+  sdkKey: string;
+  updateInterval?: number;
+  urlTemplate?: string;
+  cache?: PersistentKeyValueCache;
 }

packages/datafile-manager/src/eventEmitter.ts

@@ -14,49 +14,49 @@
  * limitations under the License.
  */
 
-export type Disposer = () => void
+export type Disposer = () => void;
 
-export type Listener = (arg?: any) => void
+export type Listener = (arg?: any) => void;
 
 interface Listeners {
-  [index: string]: { // index is event name
-    [index: string]: Listener // index is listener id
-  }
+  [index: string]: {
+    // index is event name
+    [index: string]: Listener; // index is listener id
+  };
 }
 
 export default class EventEmitter {
-  private listeners: Listeners = {}
+  private listeners: Listeners = {};
 
-  private listenerId = 1
+  private listenerId = 1;
 
   on(eventName: string, listener: Listener): Disposer {
     if (!this.listeners[eventName]) {
-      this.listeners[eventName] = {}
+      this.listeners[eventName] = {};
     }
-    const currentListenerId = String(this.listenerId)
-    this.listenerId++
-    this.listeners[eventName][currentListenerId] = listener
-    return () => {
+    const currentListenerId = String(this.listenerId);
+    this.listenerId++;
+    this.listeners[eventName][currentListenerId] = listener;
+    return (): void => {
       if (this.listeners[eventName]) {
-        delete this.listeners[eventName][currentListenerId]
+        delete this.listeners[eventName][currentListenerId];
       }
-    }
+    };
   }
 
-  emit(eventName: string, arg?: any) {
-    const listeners = this.listeners[eventName]
+  emit(eventName: string, arg?: any): void {
+    const listeners = this.listeners[eventName];
     if (listeners) {
       Object.keys(listeners).forEach(listenerId => {
-        const listener = listeners[listenerId]
-        listener(arg)
-      })
+        const listener = listeners[listenerId];
+        listener(arg);
+      });
     }
   }
 
   removeAllListeners(): void {
-    this.listeners = {}
+    this.listeners = {};
   }
 }
 
-
 // TODO: Create a typed event emitter for use in TS only (not JS)

packages/datafile-manager/src/http.ts

@@ -22,16 +22,16 @@
  * to work with multiple values per header name.
  */
 export interface Headers {
-  [header: string]: string | undefined
+  [header: string]: string | undefined;
 }
 
 export interface Response {
-  statusCode?: number
-  body: string
-  headers: Headers
+  statusCode?: number;
+  body: string;
+  headers: Headers;
 }
 
 export interface AbortableRequest {
-  abort(): void
-  responsePromise: Promise<Response>
+  abort(): void;
+  responsePromise: Promise<Response>;
 }