npm - utneque - Versions diffs - 1.0.0 - Mend

utneque 1.0.0

Files changed (431) hide show

package/packages/browser/src/browser/standalone.ts ADDED Viewed

@@ -0,0 +1,92 @@
+/* eslint-disable @typescript-eslint/no-floating-promises */
+import { getCDN, setGlobalCDNUrl } from '../lib/parse-cdn'
+import { setVersionType } from '../lib/version-type'
+if (process.env.ASSET_PATH) {
+  if (process.env.ASSET_PATH === '/dist/umd/') {
+    // @ts-ignore
+    __webpack_public_path__ = '/dist/umd/'
+  } else {
+    const cdn = getCDN()
+    setGlobalCDNUrl(cdn)
+    // @ts-ignore
+    __webpack_public_path__ = cdn
+      ? cdn + `/${process.env.PATH_PREFIX}/${process.env.PATH_VERSION}/`
+      : process.env.ASSET_PATH
+  }
+}
+setVersionType('web')
+import { install } from './standalone-analytics'
+import '../lib/csp-detection'
+import { shouldPolyfill } from '../lib/browser-polyfill'
+import { isAnalyticsCSPError } from '../lib/csp-detection'
+let ajsIdentifiedCSP = false
+// @ts-ignore
+const sendErrorMetrics = (tags: string[]) => {
+  // Uncomment to re-enable RemoteMetrics -- also see loadAnalytics() RemoteMetrics usage
+  // // this should not be instantied at the root, or it will break ie11.
+  // const metrics = new RemoteMetrics()
+  // metrics.increment('analytics_js.invoke.error', [
+  //   ...tags,
+  //   `wk:${embeddedWriteKey()}`,
+  // ])
+}
+function onError(err?: unknown) {
+  console.error('[analytics.js]', 'Failed to load Analytics.js', err)
+  sendErrorMetrics([
+    'type:initialization',
+    ...(err instanceof Error
+      ? [`message:${err?.message}`, `name:${err?.name}`]
+      : []),
+  ])
+}
+document.addEventListener('securitypolicyviolation', (e) => {
+  if (ajsIdentifiedCSP || !isAnalyticsCSPError(e)) {
+    return
+  }
+  ajsIdentifiedCSP = true
+  sendErrorMetrics(['type:csp'])
+  console.warn('Your CSP policy is missing permissions required for HtEvents')
+})
+/**
+ * Attempts to run a promise and catch both sync and async errors.
+ **/
+async function attempt<T>(promise: () => Promise<T>) {
+  try {
+    const result = await promise()
+    return result
+  } catch (err) {
+    onError(err)
+  }
+}
+if (shouldPolyfill()) {
+  // load polyfills in order to get AJS to work with old browsers
+  const script = document.createElement('script')
+  script.setAttribute(
+    'src',
+    'https://cdnjs.cloudflare.com/ajax/libs/babel-polyfill/7.7.0/polyfill.min.js'
+  )
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', () =>
+      document.body.appendChild(script)
+    )
+  } else {
+    document.body.appendChild(script)
+  }
+  script.onload = function (): void {
+    attempt(install)
+  }
+} else {
+  attempt(install)
+}

package/packages/browser/src/core/__tests__/track-form.test.ts ADDED Viewed

@@ -0,0 +1,193 @@
+import { Analytics } from '../analytics'
+import { sleep } from '../../lib/sleep'
+import { getDefaultPageContext } from '../page'
+let analytics: Analytics
+let mockTrack: jest.SpiedFunction<Analytics['track']>
+const ogLocation = {
+  ...global.window.location,
+}
+beforeEach(() => {
+  // @ts-ignore
+  global.jQuery = require('jquery')
+  jest.spyOn(console, 'error').mockImplementationOnce(() => {})
+  Object.defineProperty(window, 'location', {
+    value: ogLocation,
+    writable: true,
+  })
+  mockTrack = jest.spyOn(Analytics.prototype, 'track')
+  analytics = new Analytics({ writeKey: 'foo' })
+})
+describe('trackForm', () => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let form: any
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let submit: any
+  beforeEach(() => {
+    document.querySelector('html')!.innerHTML = `
+    <html>
+      <body>
+        <form target='_blank' action='/base/test/support/mock.html' id='form'>
+          <input type='submit' id='submit'/>
+        </form>
+      </body>
+    </html>`
+    form = document.getElementById('form')
+    submit = document.getElementById('submit')
+    // @ts-ignore
+    global.jQuery = require('jquery')
+  })
+  afterEach(() => {
+    document.querySelector('html')!.innerHTML = ''
+  })
+  it('should have the correct page context', async () => {
+    window.location.href = 'http://bar.com?foo=123'
+    window.location.search = '?foo=123'
+    await analytics.trackForm(form, 'foo', {}, { context: { ip: '0.0.0.0' } })
+    submit.click()
+    const [, , properties] = mockTrack.mock.lastCall as any[]
+    expect((properties.context as any).page).toEqual({
+      ...getDefaultPageContext(),
+      url: 'http://bar.com?foo=123',
+      search: '?foo=123',
+    })
+  })
+  it('should not error or send track event on null form', async () => {
+    const form = document.getElementById('fake-form') as HTMLFormElement
+    await analytics.trackForm(form, 'Signed Up', {
+      plan: 'Premium',
+      revenue: 99.0,
+    })
+    submit.click()
+    expect(mockTrack).not.toBeCalled()
+  })
+  it('should respect options object', async () => {
+    await analytics.trackForm(form, 'foo', {}, { context: { ip: '0.0.0.0' } })
+    submit.click()
+    expect(mockTrack).toHaveBeenCalledWith(
+      'foo',
+      {},
+      { context: expect.objectContaining({ ip: '0.0.0.0' }) }
+    )
+  })
+  it('should trigger a track on a form submit', async () => {
+    await analytics.trackForm(form, 'foo')
+    submit.click()
+    expect(mockTrack).toBeCalled()
+  })
+  it('should accept a jquery object for an element', async () => {
+    await analytics.trackForm(form, 'foo')
+    submit.click()
+    expect(mockTrack).toBeCalled()
+  })
+  it('should not accept a string for an element', async () => {
+    try {
+      // @ts-expect-error
+      await analytics.trackForm('foo')
+      submit.click()
+    } catch (e) {
+      expect(e instanceof TypeError).toBe(true)
+    }
+    expect(mockTrack).not.toBeCalled()
+  })
+  it('should send an event and properties', async () => {
+    await analytics.trackForm(form, 'event', { property: true })
+    submit.click()
+    expect(mockTrack).toBeCalledWith('event', { property: true }, {})
+  })
+  it('should accept an event function', async () => {
+    function event(): string {
+      return 'event'
+    }
+    await analytics.trackForm(form, event, { foo: 'bar' })
+    submit.click()
+    expect(mockTrack).toBeCalledWith('event', { foo: 'bar' }, {})
+  })
+  it('should accept a properties function', async () => {
+    function properties(): Record<string, boolean> {
+      return { property: true }
+    }
+    await analytics.trackForm(form, 'event', properties)
+    submit.click()
+    expect(mockTrack).toBeCalledWith('event', { property: true }, {})
+  })
+  it('should call submit after a timeout', async () => {
+    const submitSpy = jest.spyOn(form, 'submit')
+    await analytics.trackForm(form, 'foo')
+    submit.click()
+    await sleep(300)
+    expect(submitSpy).toHaveBeenCalled()
+  })
+  it('should trigger an existing submit handler', async () => {
+    const submitPromise = new Promise<void>((resolve) => {
+      form.addEventListener('submit', () => {
+        resolve()
+      })
+    })
+    await analytics.trackForm(form, 'foo')
+    submit.click()
+    await submitPromise
+  })
+  it('should trigger an existing jquery submit handler', async () => {
+    const $form = jQuery(form)
+    const submitPromise = new Promise<void>((resolve) => {
+      $form.submit(function () {
+        resolve()
+      })
+    })
+    await analytics.trackForm(form, 'foo')
+    submit.click()
+    await submitPromise
+  })
+  it('should track on a form submitted via jquery', async () => {
+    const $form = jQuery(form)
+    await analytics.trackForm(form, 'foo')
+    $form.submit()
+    expect(mockTrack).toBeCalled()
+  })
+  it('should trigger an existing jquery submit handler on a form submitted via jquery', async () => {
+    const $form = jQuery(form)
+    const submitPromise = new Promise<void>((resolve) => {
+      $form.submit(function () {
+        resolve()
+      })
+    })
+    await analytics.trackForm(form, 'foo')
+    $form.submit()
+    await submitPromise
+  })
+})

package/packages/browser/src/core/__tests__/track-link.test.ts ADDED Viewed

@@ -0,0 +1,252 @@
+import { Analytics } from '../analytics'
+import { sleep } from '../../lib/sleep'
+async function resolveWhen(
+  condition: () => boolean,
+  timeout?: number
+): Promise<void> {
+  return new Promise((resolve, _reject) => {
+    if (condition()) {
+      resolve()
+      return
+    }
+    const check = () =>
+      setTimeout(() => {
+        if (condition()) {
+          resolve()
+        } else {
+          check()
+        }
+      }, timeout)
+    check()
+  })
+}
+const ogLocation = {
+  ...global.window.location,
+}
+let analytics: Analytics
+let mockTrack: jest.SpiedFunction<Analytics['track']>
+beforeEach(() => {
+  Object.defineProperty(window, 'location', {
+    value: ogLocation,
+    writable: true,
+  })
+  mockTrack = jest.spyOn(Analytics.prototype, 'track')
+  analytics = new Analytics({ writeKey: 'foo' })
+})
+describe('trackLink', () => {
+  let link: any
+  let wrap: SVGSVGElement
+  let svg: SVGAElement
+  beforeEach(() => {
+    // @ts-ignore
+    global.jQuery = require('jquery')
+    jest.spyOn(console, 'error').mockImplementationOnce(() => {})
+    document.querySelector('html')!.innerHTML = `
+      <html>
+        <body>
+          <a href='foo.com' id='foo'></a>
+          <div id='bar'>
+            <div>
+              <a href='bar.com'></a>
+            </div>
+          </div>
+        </body>
+      </html>`
+    link = document.getElementById('foo')
+    wrap = document.createElementNS('http://www.w3.org/2000/svg', 'svg')
+    svg = document.createElementNS('http://www.w3.org/2000/svg', 'a')
+    wrap.appendChild(svg)
+    document.body.appendChild(wrap)
+  })
+  afterEach(() => {
+    document.querySelector('html')!.innerHTML = ''
+  })
+  it('should respect options object', async () => {
+    await analytics.trackLink(link!, 'foo', {}, { context: { ip: '0.0.0.0' } })
+    link.click()
+    expect(mockTrack).toHaveBeenCalledWith(
+      'foo',
+      {},
+      { context: expect.objectContaining({ ip: '0.0.0.0' }) }
+    )
+  })
+  it('should stay on same page with blank href', async () => {
+    link.href = ''
+    await analytics.trackLink(link!, 'foo')
+    link.click()
+    expect(mockTrack).toHaveBeenCalled()
+    expect(window.location.href).toBe('http://localhost/')
+  })
+  it('should work with nested link', async () => {
+    const nested = document.getElementById('bar')
+    await analytics.trackLink(nested, 'foo')
+    nested!.click()
+    expect(mockTrack).toHaveBeenCalled()
+    await resolveWhen(() => window.location.href === 'bar.com')
+    expect(window.location.href).toBe('bar.com')
+  })
+  it('should make a track call', async () => {
+    await analytics.trackLink(link!, 'foo')
+    link.click()
+    expect(mockTrack).toHaveBeenCalled()
+  })
+  it('should still navigate even if the track call fails', async () => {
+    mockTrack.mockClear()
+    let rejected = false
+    mockTrack.mockImplementationOnce(() => {
+      rejected = true
+      return Promise.reject(new Error('boo!'))
+    })
+    const nested = document.getElementById('bar')
+    await analytics.trackLink(nested, 'foo')
+    nested!.click()
+    await resolveWhen(() => rejected)
+    await resolveWhen(() => window.location.href === 'bar.com')
+    expect(window.location.href).toBe('bar.com')
+  })
+  it('should still navigate even if the track call times out', async () => {
+    mockTrack.mockClear()
+    let timedOut = false
+    mockTrack.mockImplementationOnce(async () => {
+      await sleep(600)
+      timedOut = true
+      return Promise.resolve() as any
+    })
+    const nested = document.getElementById('bar')
+    await analytics.trackLink(nested, 'foo')
+    nested!.click()
+    await resolveWhen(() => window.location.href === 'bar.com')
+    expect(window.location.href).toBe('bar.com')
+    expect(timedOut).toBe(false)
+    await resolveWhen(() => timedOut)
+  })
+  it('should accept a jquery object for an element', async () => {
+    const $link = jQuery(link)
+    await analytics.trackLink($link, 'foo')
+    link.click()
+    expect(mockTrack).toBeCalled()
+  })
+  it('accepts array of elements', async () => {
+    const links = [link, link]
+    await analytics.trackLink(links, 'foo')
+    link.click()
+    expect(mockTrack).toHaveBeenCalled()
+  })
+  it('should send an event and properties', async () => {
+    await analytics.trackLink(link, 'event', { property: true })
+    link.click()
+    expect(mockTrack).toBeCalledWith('event', { property: true }, {})
+  })
+  it('should accept an event function', async () => {
+    function event(el: Element): string {
+      return el.nodeName
+    }
+    await analytics.trackLink(link, event, { foo: 'bar' })
+    link.click()
+    expect(mockTrack).toBeCalledWith('A', { foo: 'bar' }, {})
+  })
+  it('should accept a properties function', async () => {
+    function properties(el: Record<string, string>): Record<string, string> {
+      return { type: el.nodeName }
+    }
+    await analytics.trackLink(link, 'event', properties)
+    link.click()
+    expect(mockTrack).toBeCalledWith('event', { type: 'A' }, {})
+  })
+  it('should load an href on click', async () => {
+    link.href = '#test'
+    await analytics.trackLink(link, 'foo')
+    link.click()
+    await resolveWhen(() => window.location.href === '#test')
+    expect(global.window.location.href).toBe('#test')
+  })
+  it('should only navigate after the track call has been completed', async () => {
+    link.href = '#test'
+    await analytics.trackLink(link, 'foo')
+    link.click()
+    await resolveWhen(() => mockTrack.mock.calls.length === 1)
+    await resolveWhen(() => window.location.href === '#test')
+    expect(global.window.location.href).toBe('#test')
+  })
+  it('should support svg .href attribute', async () => {
+    svg.setAttribute('href', '#svg')
+    await analytics.trackLink(svg, 'foo')
+    const clickEvent = new Event('click')
+    svg.dispatchEvent(clickEvent)
+    await resolveWhen(() => window.location.href === '#svg')
+    expect(global.window.location.href).toBe('#svg')
+  })
+  it('should fallback to getAttributeNS', async () => {
+    svg.setAttributeNS('http://www.w3.org/1999/xlink', 'href', '#svg')
+    await analytics.trackLink(svg, 'foo')
+    const clickEvent = new Event('click')
+    svg.dispatchEvent(clickEvent)
+    await resolveWhen(() => window.location.href === '#svg')
+    expect(global.window.location.href).toBe('#svg')
+  })
+  it('should support xlink:href', async () => {
+    svg.setAttribute('xlink:href', '#svg')
+    await analytics.trackLink(svg, 'foo')
+    const clickEvent = new Event('click')
+    svg.dispatchEvent(clickEvent)
+    await resolveWhen(() => window.location.href === '#svg')
+    expect(global.window.location.href).toBe('#svg')
+  })
+  it('should not load an href for a link with a blank target', async () => {
+    link.href = '/base/test/support/mock.html'
+    link.target = '_blank'
+    await analytics.trackLink(link, 'foo')
+    link.click()
+    await sleep(300)
+    expect(global.window.location.href).not.toBe('#test')
+  })
+})