utneque 1.0.0

package/packages/browser/src/core/user/vendor/crypto-es/lib/enc-base64.ts

@@ -0,0 +1,110 @@
+//@ts-nocheck
+import { WordArray } from './core'
+
+export const parseLoop = (base64Str, base64StrLength, reverseMap) => {
+  const words = []
+  let nBytes = 0
+  for (let i = 0; i < base64StrLength; i += 1) {
+    if (i % 4) {
+      const bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2)
+      const bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2)
+      const bitsCombined = bits1 | bits2
+      words[nBytes >>> 2] |= bitsCombined << (24 - (nBytes % 4) * 8)
+      nBytes += 1
+    }
+  }
+  return WordArray.create(words, nBytes)
+}
+
+/**
+ * Base64 encoding strategy.
+ */
+export const Base64 = {
+  /**
+   * Converts a word array to a Base64 string.
+   *
+   * @param {WordArray} wordArray The word array.
+   *
+   * @return {string} The Base64 string.
+   *
+   * @static
+   *
+   * @example
+   *
+   *     const base64String = CryptoJS.enc.Base64.stringify(wordArray);
+   */
+  stringify(wordArray) {
+    // Shortcuts
+    const { words, sigBytes } = wordArray
+    const map = this._map
+
+    // Clamp excess bits
+    wordArray.clamp()
+
+    // Convert
+    const base64Chars = []
+    for (let i = 0; i < sigBytes; i += 3) {
+      const byte1 = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff
+      const byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff
+      const byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff
+
+      const triplet = (byte1 << 16) | (byte2 << 8) | byte3
+
+      for (let j = 0; j < 4 && i + j * 0.75 < sigBytes; j += 1) {
+        base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f))
+      }
+    }
+
+    // Add padding
+    const paddingChar = map.charAt(64)
+    if (paddingChar) {
+      while (base64Chars.length % 4) {
+        base64Chars.push(paddingChar)
+      }
+    }
+
+    return base64Chars.join('')
+  },
+
+  /**
+   * Converts a Base64 string to a word array.
+   *
+   * @param {string} base64Str The Base64 string.
+   *
+   * @return {WordArray} The word array.
+   *
+   * @static
+   *
+   * @example
+   *
+   *     const wordArray = CryptoJS.enc.Base64.parse(base64String);
+   */
+  parse(base64Str) {
+    // Shortcuts
+    let base64StrLength = base64Str.length
+    const map = this._map
+    let reverseMap = this._reverseMap
+
+    if (!reverseMap) {
+      this._reverseMap = []
+      reverseMap = this._reverseMap
+      for (let j = 0; j < map.length; j += 1) {
+        reverseMap[map.charCodeAt(j)] = j
+      }
+    }
+
+    // Ignore padding
+    const paddingChar = map.charAt(64)
+    if (paddingChar) {
+      const paddingIndex = base64Str.indexOf(paddingChar)
+      if (paddingIndex !== -1) {
+        base64StrLength = paddingIndex
+      }
+    }
+
+    // Convert
+    return parseLoop(base64Str, base64StrLength, reverseMap)
+  },
+
+  _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
+}

package/packages/browser/src/core/user/vendor/crypto-es/lib/evpkdf.ts

@@ -0,0 +1,110 @@
+//@ts-nocheck
+import { Base, WordArray } from './core'
+import { MD5Algo } from './md5'
+
+/**
+ * This key derivation function is meant to conform with EVP_BytesToKey.
+ * www.openssl.org/docs/crypto/EVP_BytesToKey.html
+ */
+export class EvpKDFAlgo extends Base {
+  /**
+   * Initializes a newly created key derivation function.
+   *
+   * @param {Object} cfg (Optional) The configuration options to use for the derivation.
+   *
+   * @example
+   *
+   *     const kdf = CryptoJS.algo.EvpKDF.create();
+   *     const kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8 });
+   *     const kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8, iterations: 1000 });
+   */
+  constructor(cfg) {
+    super()
+
+    /**
+     * Configuration options.
+     *
+     * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)
+     * @property {Hasher} hasher The hash algorithm to use. Default: MD5
+     * @property {number} iterations The number of iterations to perform. Default: 1
+     */
+    this.cfg = Object.assign(
+      new Base(),
+      {
+        keySize: 128 / 32,
+        hasher: MD5Algo,
+        iterations: 1,
+      },
+      cfg
+    )
+  }
+
+  /**
+   * Derives a key from a password.
+   *
+   * @param {WordArray|string} password The password.
+   * @param {WordArray|string} salt A salt.
+   *
+   * @return {WordArray} The derived key.
+   *
+   * @example
+   *
+   *     const key = kdf.compute(password, salt);
+   */
+  compute(password, salt) {
+    let block
+
+    // Shortcut
+    const { cfg } = this
+
+    // Init hasher
+    const hasher = cfg.hasher.create()
+
+    // Initial values
+    const derivedKey = WordArray.create()
+
+    // Shortcuts
+    const derivedKeyWords = derivedKey.words
+    const { keySize, iterations } = cfg
+
+    // Generate key
+    while (derivedKeyWords.length < keySize) {
+      if (block) {
+        hasher.update(block)
+      }
+      block = hasher.update(password).finalize(salt)
+      hasher.reset()
+
+      // Iterations
+      for (let i = 1; i < iterations; i += 1) {
+        block = hasher.finalize(block)
+        hasher.reset()
+      }
+
+      derivedKey.concat(block)
+    }
+    derivedKey.sigBytes = keySize * 4
+
+    return derivedKey
+  }
+}
+
+/**
+ * Derives a key from a password.
+ *
+ * @param {WordArray|string} password The password.
+ * @param {WordArray|string} salt A salt.
+ * @param {Object} cfg (Optional) The configuration options to use for this computation.
+ *
+ * @return {WordArray} The derived key.
+ *
+ * @static
+ *
+ * @example
+ *
+ *     var key = CryptoJS.EvpKDF(password, salt);
+ *     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8 });
+ *     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8, iterations: 1000 });
+ */
+export const EvpKDF = (password, salt, cfg) =>
+  EvpKDFAlgo.create(cfg).compute(password, salt)

package/packages/browser/src/core/user/vendor/crypto-es/lib/md5.ts

@@ -0,0 +1,238 @@
+//@ts-nocheck
+import { WordArray, Hasher } from './core'
+
+// Constants table
+const T = []
+
+// Compute constants
+for (let i = 0; i < 64; i += 1) {
+  T[i] = (Math.abs(Math.sin(i + 1)) * 0x100000000) | 0
+}
+
+const FF = (a, b, c, d, x, s, t) => {
+  const n = a + ((b & c) | (~b & d)) + x + t
+  return ((n << s) | (n >>> (32 - s))) + b
+}
+
+const GG = (a, b, c, d, x, s, t) => {
+  const n = a + ((b & d) | (c & ~d)) + x + t
+  return ((n << s) | (n >>> (32 - s))) + b
+}
+
+const HH = (a, b, c, d, x, s, t) => {
+  const n = a + (b ^ c ^ d) + x + t
+  return ((n << s) | (n >>> (32 - s))) + b
+}
+
+const II = (a, b, c, d, x, s, t) => {
+  const n = a + (c ^ (b | ~d)) + x + t
+  return ((n << s) | (n >>> (32 - s))) + b
+}
+
+/**
+ * MD5 hash algorithm.
+ */
+export class MD5Algo extends Hasher {
+  _doReset() {
+    this._hash = new WordArray([0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476])
+  }
+
+  _doProcessBlock(M, offset) {
+    const _M = M
+
+    // Swap endian
+    for (let i = 0; i < 16; i += 1) {
+      // Shortcuts
+      const offset_i = offset + i
+      const M_offset_i = M[offset_i]
+
+      _M[offset_i] =
+        (((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff) |
+        (((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00)
+    }
+
+    // Shortcuts
+    const H = this._hash.words
+
+    const M_offset_0 = _M[offset + 0]
+    const M_offset_1 = _M[offset + 1]
+    const M_offset_2 = _M[offset + 2]
+    const M_offset_3 = _M[offset + 3]
+    const M_offset_4 = _M[offset + 4]
+    const M_offset_5 = _M[offset + 5]
+    const M_offset_6 = _M[offset + 6]
+    const M_offset_7 = _M[offset + 7]
+    const M_offset_8 = _M[offset + 8]
+    const M_offset_9 = _M[offset + 9]
+    const M_offset_10 = _M[offset + 10]
+    const M_offset_11 = _M[offset + 11]
+    const M_offset_12 = _M[offset + 12]
+    const M_offset_13 = _M[offset + 13]
+    const M_offset_14 = _M[offset + 14]
+    const M_offset_15 = _M[offset + 15]
+
+    // Working varialbes
+    let a = H[0]
+    let b = H[1]
+    let c = H[2]
+    let d = H[3]
+
+    // Computation
+    a = FF(a, b, c, d, M_offset_0, 7, T[0])
+    d = FF(d, a, b, c, M_offset_1, 12, T[1])
+    c = FF(c, d, a, b, M_offset_2, 17, T[2])
+    b = FF(b, c, d, a, M_offset_3, 22, T[3])
+    a = FF(a, b, c, d, M_offset_4, 7, T[4])
+    d = FF(d, a, b, c, M_offset_5, 12, T[5])
+    c = FF(c, d, a, b, M_offset_6, 17, T[6])
+    b = FF(b, c, d, a, M_offset_7, 22, T[7])
+    a = FF(a, b, c, d, M_offset_8, 7, T[8])
+    d = FF(d, a, b, c, M_offset_9, 12, T[9])
+    c = FF(c, d, a, b, M_offset_10, 17, T[10])
+    b = FF(b, c, d, a, M_offset_11, 22, T[11])
+    a = FF(a, b, c, d, M_offset_12, 7, T[12])
+    d = FF(d, a, b, c, M_offset_13, 12, T[13])
+    c = FF(c, d, a, b, M_offset_14, 17, T[14])
+    b = FF(b, c, d, a, M_offset_15, 22, T[15])
+
+    a = GG(a, b, c, d, M_offset_1, 5, T[16])
+    d = GG(d, a, b, c, M_offset_6, 9, T[17])
+    c = GG(c, d, a, b, M_offset_11, 14, T[18])
+    b = GG(b, c, d, a, M_offset_0, 20, T[19])
+    a = GG(a, b, c, d, M_offset_5, 5, T[20])
+    d = GG(d, a, b, c, M_offset_10, 9, T[21])
+    c = GG(c, d, a, b, M_offset_15, 14, T[22])
+    b = GG(b, c, d, a, M_offset_4, 20, T[23])
+    a = GG(a, b, c, d, M_offset_9, 5, T[24])
+    d = GG(d, a, b, c, M_offset_14, 9, T[25])
+    c = GG(c, d, a, b, M_offset_3, 14, T[26])
+    b = GG(b, c, d, a, M_offset_8, 20, T[27])
+    a = GG(a, b, c, d, M_offset_13, 5, T[28])
+    d = GG(d, a, b, c, M_offset_2, 9, T[29])
+    c = GG(c, d, a, b, M_offset_7, 14, T[30])
+    b = GG(b, c, d, a, M_offset_12, 20, T[31])
+
+    a = HH(a, b, c, d, M_offset_5, 4, T[32])
+    d = HH(d, a, b, c, M_offset_8, 11, T[33])
+    c = HH(c, d, a, b, M_offset_11, 16, T[34])
+    b = HH(b, c, d, a, M_offset_14, 23, T[35])
+    a = HH(a, b, c, d, M_offset_1, 4, T[36])
+    d = HH(d, a, b, c, M_offset_4, 11, T[37])
+    c = HH(c, d, a, b, M_offset_7, 16, T[38])
+    b = HH(b, c, d, a, M_offset_10, 23, T[39])
+    a = HH(a, b, c, d, M_offset_13, 4, T[40])
+    d = HH(d, a, b, c, M_offset_0, 11, T[41])
+    c = HH(c, d, a, b, M_offset_3, 16, T[42])
+    b = HH(b, c, d, a, M_offset_6, 23, T[43])
+    a = HH(a, b, c, d, M_offset_9, 4, T[44])
+    d = HH(d, a, b, c, M_offset_12, 11, T[45])
+    c = HH(c, d, a, b, M_offset_15, 16, T[46])
+    b = HH(b, c, d, a, M_offset_2, 23, T[47])
+
+    a = II(a, b, c, d, M_offset_0, 6, T[48])
+    d = II(d, a, b, c, M_offset_7, 10, T[49])
+    c = II(c, d, a, b, M_offset_14, 15, T[50])
+    b = II(b, c, d, a, M_offset_5, 21, T[51])
+    a = II(a, b, c, d, M_offset_12, 6, T[52])
+    d = II(d, a, b, c, M_offset_3, 10, T[53])
+    c = II(c, d, a, b, M_offset_10, 15, T[54])
+    b = II(b, c, d, a, M_offset_1, 21, T[55])
+    a = II(a, b, c, d, M_offset_8, 6, T[56])
+    d = II(d, a, b, c, M_offset_15, 10, T[57])
+    c = II(c, d, a, b, M_offset_6, 15, T[58])
+    b = II(b, c, d, a, M_offset_13, 21, T[59])
+    a = II(a, b, c, d, M_offset_4, 6, T[60])
+    d = II(d, a, b, c, M_offset_11, 10, T[61])
+    c = II(c, d, a, b, M_offset_2, 15, T[62])
+    b = II(b, c, d, a, M_offset_9, 21, T[63])
+
+    // Intermediate hash value
+    H[0] = (H[0] + a) | 0
+    H[1] = (H[1] + b) | 0
+    H[2] = (H[2] + c) | 0
+    H[3] = (H[3] + d) | 0
+  }
+  /* eslint-ensable no-param-reassign */
+
+  _doFinalize() {
+    // Shortcuts
+    const data = this._data
+    const dataWords = data.words
+
+    const nBitsTotal = this._nDataBytes * 8
+    const nBitsLeft = data.sigBytes * 8
+
+    // Add padding
+    dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - (nBitsLeft % 32))
+
+    const nBitsTotalH = Math.floor(nBitsTotal / 0x100000000)
+    const nBitsTotalL = nBitsTotal
+    dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] =
+      (((nBitsTotalH << 8) | (nBitsTotalH >>> 24)) & 0x00ff00ff) |
+      (((nBitsTotalH << 24) | (nBitsTotalH >>> 8)) & 0xff00ff00)
+    dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] =
+      (((nBitsTotalL << 8) | (nBitsTotalL >>> 24)) & 0x00ff00ff) |
+      (((nBitsTotalL << 24) | (nBitsTotalL >>> 8)) & 0xff00ff00)
+
+    data.sigBytes = (dataWords.length + 1) * 4
+
+    // Hash final blocks
+    this._process()
+
+    // Shortcuts
+    const hash = this._hash
+    const H = hash.words
+
+    // Swap endian
+    for (let i = 0; i < 4; i += 1) {
+      // Shortcut
+      const H_i = H[i]
+
+      H[i] =
+        (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff) |
+        (((H_i << 24) | (H_i >>> 8)) & 0xff00ff00)
+    }
+
+    // Return final computed hash
+    return hash
+  }
+
+  clone() {
+    const clone = super.clone.call(this)
+    clone._hash = this._hash.clone()
+
+    return clone
+  }
+}
+
+/**
+ * Shortcut function to the hasher's object interface.
+ *
+ * @param {WordArray|string} message The message to hash.
+ *
+ * @return {WordArray} The hash.
+ *
+ * @static
+ *
+ * @example
+ *
+ *     var hash = CryptoJS.MD5('message');
+ *     var hash = CryptoJS.MD5(wordArray);
+ */
+export const MD5 = Hasher._createHelper(MD5Algo)
+
+/**
+ * Shortcut function to the HMAC's object interface.
+ *
+ * @param {WordArray|string} message The message to hash.
+ * @param {WordArray|string} key The secret key.
+ *
+ * @return {WordArray} The HMAC.
+ *
+ * @static
+ *
+ * @example
+ *
+ *     var hmac = CryptoJS.HmacMD5(message, key);
+ */
+export const HmacMD5 = Hasher._createHmacHelper(MD5Algo)

package/packages/browser/src/core/user/vendor/readme.md

@@ -0,0 +1,7 @@
+# Why are we vendoring crypto-es?
+
+> jest syntaxerror: cannot use import statement outside a module
+
+Crypto-es decided to write their package in "esm" style modules, with a ".js" extension, with no babel or other build step. It doesn't work with jest + typescript. https://github.com/jestjs/jest/issues/9430 https://github.com/jestjs/jest/issues/12990
+
+We need crypto-es to "decrypt" Rudder's anonymousId. We've vendored crypto-es (along with its MIT license https://github.com/entronad/crypto-es/blob/master/LICENSE) instead of continuing on the esm + jest issue.

package/packages/browser/src/generated/__tests__/version.test.ts

@@ -0,0 +1,18 @@
+import { version } from '../version'
+import { readFileSync } from 'fs'
+import { resolve as resolvePath } from 'path'
+
+function getPackageJsonVersion(): string {
+  const packageJson = JSON.parse(
+    readFileSync(
+      resolvePath(__dirname, '..', '..', '..', 'package.json')
+    ).toString()
+  )
+  return packageJson.version
+}
+
+describe('version', () => {
+  it('matches version in package.json', async () => {
+    expect(version).toBe(getPackageJsonVersion())
+  })
+})

package/packages/browser/src/generated/version.ts

@@ -0,0 +1,2 @@
+// This file is generated.
+export const version = '1.1.0'

package/packages/browser/src/index.ts

@@ -0,0 +1,13 @@
+export * from './core/analytics'
+export * from './browser'
+export * from './node'
+
+export * from './core/context'
+export * from './core/events'
+export * from './core/plugin'
+export * from './core/user'
+
+export type { HtEventsSnippet } from './browser/standalone-interface'
+export type { MiddlewareFunction } from './plugins/middleware'
+export { getGlobalAnalytics } from './lib/global-analytics-helper'
+export { UniversalStorage, Store, StorageObject } from './core/storage'

package/packages/browser/src/lib/__tests__/embedded-write-key.test.ts

@@ -0,0 +1,15 @@
+import { embeddedWriteKey } from '../embedded-write-key'
+
+it('it guards against undefined', () => {
+  expect(embeddedWriteKey()).toBe(undefined)
+})
+
+it('it returns undefined when default parameter is set', () => {
+  window.analyticsWriteKey = '__WRITE_KEY__'
+  expect(embeddedWriteKey()).toBe(undefined)
+})
+
+it('it returns the write key when the key is set properly', () => {
+  window.analyticsWriteKey = 'abc_123_write_key'
+  expect(embeddedWriteKey()).toBe('abc_123_write_key')
+})

package/packages/browser/src/lib/__tests__/fetch.test.ts

@@ -0,0 +1,35 @@
+import { fetch } from '../fetch'
+import { getGlobal } from '../get-global'
+import unfetch from 'unfetch'
+
+jest.mock('unfetch')
+const unfetchMock = jest.mocked(unfetch).mockResolvedValue({} as Response)
+
+jest.mock('../get-global')
+const getGlobalMock = jest.mocked(getGlobal)
+
+describe(fetch, () => {
+  const testFetchArgs = ['http://foo.com', {}] as const
+
+  it('should call native fetch if available', () => {
+    const nativeFetchMock = jest.fn()
+    getGlobalMock.mockReturnValue({ ...window, fetch: nativeFetchMock })
+    void fetch(...testFetchArgs)
+    expect(nativeFetchMock).toBeCalledWith(...testFetchArgs)
+    expect(unfetchMock).not.toBeCalled()
+  })
+  it('should fall back to unfetch in non-browserlike environment', () => {
+    getGlobalMock.mockReturnValue(null)
+    void fetch(...testFetchArgs)
+    expect(unfetchMock).toBeCalledWith(...testFetchArgs)
+  })
+  it('should fall back to unfetch if native fetch is unsupported', () => {
+    getGlobalMock.mockReturnValue({
+      ...window,
+      fetch: undefined,
+    } as any)
+
+    void fetch(...testFetchArgs)
+    expect(unfetchMock).toBeCalledWith(...testFetchArgs)
+  })
+})

package/packages/browser/src/lib/__tests__/get-process-env.test.ts

@@ -0,0 +1,5 @@
+import { getProcessEnv } from '../get-process-env'
+
+it('it matches the contents of process.env', () => {
+  expect(getProcessEnv()).toBe(process.env)
+})

package/packages/browser/src/lib/__tests__/group-by.test.ts

@@ -0,0 +1,96 @@
+import { groupBy } from '../group-by'
+
+describe('groupBy', () => {
+  it('groups a collection by key', () => {
+    const collection = [
+      {
+        id: 'go',
+        type: 'server',
+      },
+      {
+        id: 'ruby',
+        type: 'server',
+      },
+      {
+        id: 'js',
+        type: 'browser',
+      },
+      {
+        id: 'react',
+        type: 'app',
+      },
+    ]
+
+    expect(groupBy(collection, 'type')).toEqual({
+      app: [
+        {
+          id: 'react',
+          type: 'app',
+        },
+      ],
+      browser: [
+        {
+          id: 'js',
+          type: 'browser',
+        },
+      ],
+      server: [
+        {
+          id: 'go',
+          type: 'server',
+        },
+        {
+          id: 'ruby',
+          type: 'server',
+        },
+      ],
+    })
+  })
+
+  it('accepts a function', () => {
+    const collection = [
+      {
+        id: 1,
+        type: 'server',
+      },
+      {
+        id: 2,
+        type: 'server',
+      },
+      {
+        id: 3,
+        type: 'browser',
+      },
+      {
+        id: 4,
+        type: 'app',
+      },
+    ]
+
+    const oddEven = groupBy(collection, (c) =>
+      c.id % 2 === 0 ? 'even' : 'odd'
+    )
+    expect(oddEven).toEqual({
+      even: [
+        {
+          id: 2,
+          type: 'server',
+        },
+        {
+          id: 4,
+          type: 'app',
+        },
+      ],
+      odd: [
+        {
+          id: 1,
+          type: 'server',
+        },
+        {
+          id: 3,
+          type: 'browser',
+        },
+      ],
+    })
+  })
+})

package/packages/browser/src/lib/__tests__/is-plan-event-enabled.test.ts

@@ -0,0 +1,36 @@
+import { Plan } from '../../core/events/interfaces'
+import { isPlanEventEnabled } from '../is-plan-event-enabled'
+
+describe('isPlanEventEnabled', () => {
+  it('handles tracking plans that allow unplanned events', () => {
+    const plan: Plan['track'] = {
+      __default: { enabled: true, integrations: {} },
+    }
+
+    expect(isPlanEventEnabled(plan, { enabled: true, integrations: {} })).toBe(
+      true
+    )
+    expect(isPlanEventEnabled(plan, { enabled: false, integrations: {} })).toBe(
+      false
+    )
+    expect(isPlanEventEnabled(plan, undefined)).toBe(true)
+  })
+
+  it('handles tracking plans that disallow unplanned events', () => {
+    const plan: Plan['track'] = {
+      __default: { enabled: false, integrations: {} },
+    }
+
+    expect(isPlanEventEnabled(plan, { enabled: true, integrations: {} })).toBe(
+      true
+    )
+    expect(isPlanEventEnabled(plan, { enabled: false, integrations: {} })).toBe(
+      false
+    )
+    expect(isPlanEventEnabled(plan, undefined)).toBe(false)
+  })
+
+  it('allows event when tracking plan does not exist', () => {
+    expect(isPlanEventEnabled(undefined, undefined)).toBe(true)
+  })
+})