[No Ticket] Cleanup pass and enable strict mode

.eslintrc.js

@@ -17,5 +17,7 @@ module.exports = {
     'plugin:@typescript-eslint/recommended'
   ],
   globals: {},
-  rules: {}
+  rules: {
+    "@typescript-eslint/ban-ts-comment": 0
+  }
 }

rollup/dist.config.js

@@ -18,7 +18,7 @@ export default {
   ],
   plugins: [
     cleaner({targets: [OUTPUT_DIR]}),
-    ts({transpileOnly: true, tsconfig: resolvedConfig => ({...resolvedConfig, declaration: true})}),
+    ts(),
     resolve(),
     commonjs(),
     strip(),

rollup/test-resources.config.js

@@ -19,7 +19,7 @@ export default {
   },
   plugins: [
     cleaner({targets: [OUTPUT_DIR]}),
-    ts({transpileOnly: true}),
+    ts({tsconfig: resolvedConfig => ({...resolvedConfig, declaration: false})}),
     resolve(),
     commonjs(),
     babel(),

src/config-validators/remove-invalid-pairs.ts

@@ -1,6 +1,6 @@
 import { EventBus, LiveConnectConfig } from '../types'
 
-export function removeInvalidPairs (config: LiveConnectConfig, eventBus: EventBus) {
+export function removeInvalidPairs (config: LiveConnectConfig, eventBus: EventBus): LiveConnectConfig {
   if (config && config.appId && config.distributorId) {
     const distributorId = config.distributorId
     delete config.distributorId

src/enrichers/identifiers-nohash.ts

@@ -1,8 +1,9 @@
 import { containsEmailField, isEmail } from '../utils/email'
 import { safeToString, isArray, trim } from '../utils/types'
-import { EventBus, IMinimalStorageHandler, State } from '../types'
+import { EventBus, RetrievedIdentifier, State } from '../types'
+import { MinimalStorageHandler } from '../handlers/storage-handler'
 
-export function enrich (state: State, storageHandler: IMinimalStorageHandler, eventBus: EventBus): State {
+export function enrich (state: State, storageHandler: MinimalStorageHandler, eventBus: EventBus): State {
   try {
     return _parseIdentifiersToResolve(state, storageHandler)
   } catch (e) {
@@ -11,10 +12,10 @@ export function enrich (state: State, storageHandler: IMinimalStorageHandler, ev
   }
 }
 
-function _parseIdentifiersToResolve (state: State, storageHandler: IMinimalStorageHandler): State {
+function _parseIdentifiersToResolve (state: State, storageHandler: MinimalStorageHandler): State {
   state.identifiersToResolve = state.identifiersToResolve || []
   const cookieNames = isArray(state.identifiersToResolve) ? state.identifiersToResolve : safeToString(state.identifiersToResolve).split(',')
-  const identifiers = []
+  const identifiers: RetrievedIdentifier[] = []
   for (let i = 0; i < cookieNames.length; i++) {
     const identifierName = trim(cookieNames[i])
     const identifierValue = storageHandler.getCookie(identifierName) || storageHandler.getDataFromLocalStorage(identifierName)

src/enrichers/identifiers.ts

@@ -1,18 +1,21 @@
 import { replaceEmailsWithHashes } from '../utils/email'
 import { safeToString, isString, isArray } from '../utils/types'
-import { EventBus, HashedEmail, IMinimalStorageHandler, State } from '../types'
+import { EventBus, HashedEmail, State, RetrievedIdentifier } from '../types'
+import { MinimalStorageHandler } from '../handlers/storage-handler'
 
-export function enrich (state: State, storageHandler: IMinimalStorageHandler, eventBus: EventBus) {
+export function enrich (state: State, storageHandler: MinimalStorageHandler, eventBus: EventBus): State {
   try {
     return _getIdentifiers(_parseIdentifiersToResolve(state), storageHandler)
   } catch (e) {
-    eventBus.emitError('IdentifiersEnricher', e)
+    if (eventBus) {
+      eventBus.emitError('IdentifiersEnricher', e)
+    }
     return {}
   }
 }
 
 function _parseIdentifiersToResolve (state: State): string[] {
-  let cookieNames = []
+  let cookieNames: string[] = []
   if (state.identifiersToResolve) {
     if (isArray(state.identifiersToResolve)) {
       cookieNames = state.identifiersToResolve as string[]
@@ -26,9 +29,9 @@ function _parseIdentifiersToResolve (state: State): string[] {
   return cookieNames
 }
 
-function _getIdentifiers (cookieNames: string[], storageHandler: IMinimalStorageHandler): State {
-  const identifiers = []
-  let hashes = []
+function _getIdentifiers (cookieNames: string[], storageHandler: MinimalStorageHandler): State {
+  const identifiers: RetrievedIdentifier[] = []
+  let hashes: HashedEmail[] = []
   for (let i = 0; i < cookieNames.length; i++) {
     const identifierName = cookieNames[i]
     const identifierValue = storageHandler.getCookie(identifierName) || storageHandler.getDataFromLocalStorage(identifierName)
@@ -48,12 +51,12 @@ function _getIdentifiers (cookieNames: string[], storageHandler: IMinimalStorage
 }
 
 function _deduplicateHashes (hashes: HashedEmail[]): HashedEmail[] {
-  const seen = {}
-  const result = []
+  const seen = new Set<string>()
+  const result: HashedEmail[] = []
   for (let i = 0; i < hashes.length; i++) {
-    if (!(hashes[i].md5 in seen)) {
+    if (!seen.has(hashes[i].md5)) {
       result.push(hashes[i])
-      seen[hashes[i].md5] = true
+      seen.add(hashes[i].md5)
     }
   }
   return result

src/enrichers/page.ts

@@ -4,15 +4,18 @@ import { getPage, getReferrer, getContextElements } from '../utils/page'
 /**
  * @private
  */
-let _currentPage = null
+let _currentPage: State | null = null
 
 export function enrich (state: State): State {
-  if (!_currentPage) {
-    _currentPage = {
+  if (_currentPage) {
+    return _currentPage
+  } else {
+    const result = {
       pageUrl: getPage(),
       referrer: getReferrer(),
       contextElements: getContextElements(state.privacyMode, state.contextSelectors, state.contextElementsLength)
     }
+    _currentPage = result
+    return result
   }
-  return _currentPage
 }

src/enrichers/people-verified.ts

@@ -1,9 +1,10 @@
 import { PEOPLE_VERIFIED_LS_ENTRY } from '../utils/consts'
-import { EventBus, IMinimalStorageHandler, State } from '../types'
+import { EventBus, State } from '../types'
+import { MinimalStorageHandler } from '../handlers/storage-handler'
 
-export function enrich (state: State, storageHandler: IMinimalStorageHandler, eventBus: EventBus) {
+export function enrich (state: State, storageHandler: MinimalStorageHandler, eventBus: EventBus): State {
   try {
-    return { peopleVerifiedId: state.peopleVerifiedId || storageHandler.getDataFromLocalStorage(PEOPLE_VERIFIED_LS_ENTRY) }
+    return { peopleVerifiedId: state.peopleVerifiedId || storageHandler.getDataFromLocalStorage(PEOPLE_VERIFIED_LS_ENTRY) || undefined }
   } catch (e) {
     eventBus.emitError('PeopleVerifiedEnrich', e)
     return {}

src/events/error-pixel.ts

@@ -2,10 +2,9 @@ import { PixelSender } from '../pixel/sender'
 import { StateWrapper } from '../pixel/state'
 import * as page from '../enrichers/page'
 import * as C from '../utils/consts'
-import { EventBus, ICallHandler, IPixelSender, State } from '../types'
+import { EventBus, State } from '../types'
+import { CallHandler } from '../handlers/call-handler'
 
-let _state = null
-let _pixelSender: IPixelSender = null
 const MAX_ERROR_FIELD_LENGTH = 120
 
 const _defaultReturn: State = {
@@ -15,16 +14,16 @@ const _defaultReturn: State = {
   }
 }
 
-function _asInt (field: any): number | undefined {
+function _asInt (field: unknown): number | undefined {
   try {
-    const intValue = field * 1
+    const intValue = (field as number) * 1
     return isNaN(intValue) ? undefined : intValue
   } catch {
 
   }
 }
 
-function _truncate (value: string): string {
+function _truncate (value: string | undefined): string | undefined {
   try {
     if (value && value.length && value.length > MAX_ERROR_FIELD_LENGTH) {
       return `${value.substr(0, MAX_ERROR_FIELD_LENGTH)}...`
@@ -39,11 +38,11 @@ export function asErrorDetails (e: any): State {
   if (e) {
     return {
       errorDetails: {
-        message: _truncate(e.message),
-        name: _truncate(e.name),
+        message: _truncate(e.message) || '',
+        name: _truncate(e.name) || '',
         stackTrace: _truncate(e.stack),
         lineNumber: _asInt(e.lineNumber),
-        lineColumn: _asInt(e.lineColumn),
+        columnNumber: _asInt(e.columnNumber),
         fileName: _truncate(e.fileName)
       }
     }
@@ -52,14 +51,12 @@ export function asErrorDetails (e: any): State {
   }
 }
 
-export function register (state: State, callHandler: ICallHandler, eventBus: EventBus): void {
+export function register (state: State, callHandler: CallHandler, eventBus: EventBus): void {
   try {
-    _pixelSender = new PixelSender(state, callHandler, eventBus)
-    _state = state || {}
+    const pixelSender = new PixelSender(state, callHandler, eventBus)
 
     eventBus.on(C.ERRORS_PREFIX, (error) => {
-      console.log(error, _state)
-      _pixelSender.sendPixel(new StateWrapper(asErrorDetails(error), eventBus).combineWith(_state || {}).combineWith(page.enrich({})))
+      pixelSender.sendPixel(new StateWrapper(asErrorDetails(error), eventBus).combineWith(state || {}).combineWith(page.enrich({})))
     })
   } catch (e) {
     console.error('handlers.error.register', e)

src/events/event-bus.ts

@@ -1,13 +1,15 @@
+// @ts-nocheck
 import { ReplayEmitter, wrapError } from './replayemitter'
 import * as C from '../utils/consts'
 import { isFunction } from '../utils/types'
 import { EventBus } from '../types'
 
 function initBus (size?: number): EventBus {
-  if (typeof size === 'undefined') {
-    size = 5
+  if (typeof size === 'number' && size >= 0) {
+    return new ReplayEmitter(size)
+  } else {
+    return new ReplayEmitter(5)
   }
-  return new ReplayEmitter(size)
 }
 
 function extendBusIfNeeded (bus: EventBus) {

src/events/replayemitter.ts

@@ -1,16 +1,17 @@
 import * as C from '../utils/consts'
-import { EventBus } from '../types'
+import { ErrorDetails, EventBus } from '../types'
+import { isObject } from '../utils/types'
 
-type Callback<Ctx> = (ctx: Ctx, data: any[]) => void
+type Callback = (data: any[]) => void
 
-interface EventHandler<Ctx> {
-  ctx?: Ctx,
-  fn: Callback<Ctx>
+interface EventHandler {
+  ctx?: any,
+  fn: (data: any) => void
 }
 
 export class ReplayEmitter implements EventBus {
-  h: Record<string, EventHandler<any>[]>;
-  q: Record<string, any[]>;
+  private h: Record<string, EventHandler[]>;
+  private q: Record<string, any[]>;
   size: number;
 
   constructor (replaySize: number | string) {
@@ -26,8 +27,8 @@ export class ReplayEmitter implements EventBus {
     this.q = {}
   }
 
-  on <Ctx> (name: string, callback: Callback<Ctx>, ctx: Ctx): EventBus {
-    const handler: EventHandler<Ctx> = {
+  on (name: string, callback: Callback, ctx?: any): this {
+    const handler: EventHandler = {
       ctx: ctx,
       fn: callback
     };
@@ -42,14 +43,13 @@ export class ReplayEmitter implements EventBus {
     return this
   }
 
-  once <Ctx> (name: string, callback: Callback<Ctx>, ctx: Ctx): EventBus {
+  once (name: string, callback: Callback, ctx?: any): this {
     const eventQueue = this.q[name] || []
     if (eventQueue.length > 0) {
       callback.apply(ctx, eventQueue[0])
-
       return this
     } else {
-      const listener = (...args: any[]) => {
+      const listener = (...args: [data: any]) => {
         this.off(name, listener)
         callback.apply(ctx, args)
       }
@@ -59,13 +59,13 @@ export class ReplayEmitter implements EventBus {
     }
   }
 
-  emit (name: string, ...data: any[]): EventBus {
+  emit (name: string, ...data: any[]): this {
     const evtArr = (this.h[name] || []).slice()
     let i = 0
     const len = evtArr.length
 
     for (i; i < len; i++) {
-      evtArr[i].fn.apply(evtArr[i].ctx, data)
+      evtArr[i].fn.apply(evtArr[i].ctx, data as [data: any])
     }
 
     const eventQueue = this.q[name] || (this.q[name] = [])
@@ -77,7 +77,7 @@ export class ReplayEmitter implements EventBus {
     return this
   }
 
-  off (name: string, callback: Callback<any>): EventBus {
+  off (name: string, callback: Callback): this {
     const handlers = this.h[name]
     const liveEvents = []
 
@@ -96,21 +96,41 @@ export class ReplayEmitter implements EventBus {
     return this
   }
 
-  emitErrorWithMessage (name: string, message: string, e: any = {}): EventBus {
-    const wrappedError = wrapError(name, message, e)
+  emitErrorWithMessage (name: string, message: string, exception: unknown): this {
+    const wrappedError = wrapError(name, message, exception)
     return this.emit(C.ERRORS_PREFIX, wrappedError)
   }
 
-  emitError (name: string, exception: any): EventBus {
-    return this.emitErrorWithMessage(name, exception.message, exception)
+  emitError (name: string, exception: unknown): this {
+    const wrappedError = wrapError(name, undefined, exception)
+    return this.emit(C.ERRORS_PREFIX, wrappedError)
   }
 }
 
-export function wrapError (name: string, message: string, e: any): any {
-  const wrapped: any = new Error(message || e.message)
-  wrapped.stack = e.stack
-  wrapped.name = name || 'unknown error'
-  wrapped.lineNumber = e.lineNumber
-  wrapped.columnNumber = e.columnNumber
-  return wrapped
+export function wrapError (name: string, message?: string, e?: unknown): ErrorDetails {
+  if (isObject(e)) {
+    let error: ErrorDetails
+    if ('message' in e && typeof e.message === 'string') {
+      error = new Error(message || e.message)
+    } else {
+      error = new Error(message)
+    }
+
+    error.name = name
+
+    if ('stack' in e && typeof e.stack === 'string') {
+      error.stack = e.stack
+    }
+    if ('lineNumber' in e && typeof e.lineNumber === 'number') {
+      error.lineNumber = e.lineNumber
+    }
+    if ('columnNumber' in e && typeof e.columnNumber === 'number') {
+      error.columnNumber = e.columnNumber
+    }
+    return error
+  } else {
+    const error = Error(message)
+    error.name = name
+    return error
+  }
 }