@procore/core-react 11.25.1 → 11.25.2

package/dist/_hooks/__tests__/Deprecation.test.js

@@ -1,58 +0,0 @@
-import { renderHook } from '@testing-library/react-hooks'
-
-import { useDeprecation } from '../Deprecation'
-
-const oldThing = 'Boooo'
-const newThing = 'Yaaaay'
-const link = 'https://dwitter.net'
-
-/* eslint-disable no-console */
-describe('useDeprecation', () => {
-  let spy
-  beforeEach(() => {
-    spy = jest.spyOn(console, 'warn').mockImplementation(() => {})
-  })
-
-  afterEach(() => {
-    spy.mockRestore()
-  })
-
-  const checkIsWarningCalled = (times = 1) => {
-    expect(spy).toBeCalledTimes(times)
-
-    for (let i = 0; i < times; i++) {
-      expect(console.warn.mock.calls[i][0]).toContain(
-        `${oldThing} is deprecated, please use ${newThing}`
-      )
-      expect(console.warn.mock.calls[i][1]).toContain(`${link}`)
-    }
-  }
-
-  it('should warn without passing "when"', () => {
-    renderHook(() => useDeprecation({ oldThing, newThing, link }))
-    checkIsWarningCalled()
-  })
-
-  it('should warn when "when" is truthy', () => {
-    renderHook(() => useDeprecation({ oldThing, newThing, link, when: true }))
-    renderHook(() => useDeprecation({ oldThing, newThing, link, when: 'prop' }))
-    checkIsWarningCalled(2)
-  })
-
-  it('should warn when "when" is falsy(except undefined)', () => {
-    renderHook(() => useDeprecation({ oldThing, newThing, link, when: 0 }))
-    renderHook(() => useDeprecation({ oldThing, newThing, link, when: null }))
-    renderHook(() => useDeprecation({ oldThing, newThing, link, when: false }))
-    renderHook(() => useDeprecation({ oldThing, newThing, link, when: '' }))
-    checkIsWarningCalled(4)
-  })
-
-  it('should not warn when "when" is undefined', () => {
-    renderHook(() =>
-      useDeprecation({ oldThing, newThing, link, when: undefined })
-    )
-
-    expect(spy).toBeCalledTimes(0)
-  })
-})
-/* eslint-enable no-console */

package/dist/_hooks/__tests__/Event.test.js

@@ -1,46 +0,0 @@
-import {
-  testContext,
-  testHook,
-  testRenderProp,
-} from '../../__tests__/helpers/state'
-import { Event, EventProvider, useEvent, useEventContext } from '../Event'
-
-const validateAPI = (api) => {
-  expect(api.value).toEqual(null)
-}
-
-const apiTest = {
-  test: 'api',
-  config: {},
-  callback: validateAPI,
-}
-
-jest.spyOn(global.console, 'warn').mockImplementation(() => {})
-
-afterAll(() => {
-  jest.clearAllMocks()
-})
-
-describe('Event', () => {
-  testHook(useEvent, [
-    apiTest,
-    {
-      test: 'mutations',
-      config: { initialValue: 'foo' },
-    },
-  ])
-
-  testRenderProp(Event, 'event', [apiTest])
-
-  testContext(EventProvider, useEventContext, [
-    apiTest,
-    {
-      test: 'missing provider',
-      config: {},
-      injectProvider: false,
-      callback: (context, { spy }) => {
-        expect(context.value).toBe(null)
-      },
-    },
-  ])
-})

package/dist/_hooks/__tests__/EventListener.test.js

@@ -1,124 +0,0 @@
-import { mount } from 'enzyme'
-import React from 'react'
-
-import { useEventListener } from '../EventListener'
-
-function noop() {}
-
-const mockScope = () => {
-  const listeners = {}
-
-  const scope = {
-    addEventListener: jest.fn((event, cb) => {
-      listeners[event] = cb
-    }),
-    removeEventListener: jest.fn((event, cb) => {
-      listeners[event] = null
-    }),
-  }
-
-  return { current: scope }
-}
-
-const mockWindowScope = () => {
-  const listeners = {}
-
-  const scope = {
-    addEventListener: jest.fn((event, cb) => {
-      listeners[event] = cb
-    }),
-    removeEventListener: jest.fn((event, cb) => {
-      listeners[event] = null
-    }),
-  }
-
-  return scope
-}
-
-const Enhanced = (props) => {
-  useEventListener(props)
-
-  return null
-}
-
-describe('useEventListener', () => {
-  describe('scope changes', () => {
-    const scopeA = mockScope()
-    const scopeB = mockScope()
-
-    mount(<Enhanced event="scroll" handler={noop} scope={scopeA} />).setProps({
-      scope: scopeB,
-    })
-
-    it('adds and removes listeners to scope when scope changes', (done) => {
-      setTimeout(() => {
-        expect(scopeA.current.removeEventListener).toBeCalledTimes(1)
-        expect(scopeB.current.addEventListener).toBeCalledTimes(1)
-        done()
-      }, 10)
-    })
-  })
-
-  describe('scope types', () => {
-    const scopeA = mockWindowScope()
-
-    mount(<Enhanced event="scroll" handler={noop} scope={scopeA} />)
-
-    it('adds listeners to custom window scope', (done) => {
-      setTimeout(() => {
-        expect(scopeA.addEventListener).toBeCalledTimes(1)
-        done()
-      }, 10)
-    })
-
-    it('adds listeners to ref scope', (done) => {
-      const scopeB = mockScope()
-
-      mount(<Enhanced event="scroll" handler={noop} scope={scopeB} />)
-
-      setTimeout(() => {
-        expect(scopeB.current.addEventListener).toBeCalledTimes(1)
-        done()
-      }, 10)
-    })
-
-    it('adds listeners to window when no scope is passed', () => {
-      global.addEventListener = jest.fn()
-      mount(<Enhanced event="scroll" handler={noop} />)
-
-      expect(global.addEventListener).toHaveBeenCalled()
-    })
-  })
-
-  describe('event type changes', () => {
-    const scope = mockScope()
-
-    mount(<Enhanced event="scroll" handler={noop} scope={scope} />).setProps({
-      event: 'resize',
-    })
-
-    it('adds and removes listeners from scope when event changes', (done) => {
-      setTimeout(() => {
-        expect(scope.current.addEventListener).toBeCalledTimes(2)
-        expect(scope.current.removeEventListener).toBeCalledTimes(1)
-        done()
-      }, 10)
-    })
-  })
-
-  describe('handler changes', () => {
-    const scope = mockScope()
-
-    mount(<Enhanced event="scroll" handler={noop} scope={scope} />).setProps({
-      handler: () => {},
-    })
-
-    it('keeps the same listener when handler changes', (done) => {
-      setTimeout(() => {
-        expect(scope.current.addEventListener).toBeCalledTimes(1)
-        expect(scope.current.removeEventListener).toBeCalledTimes(0)
-        done()
-      }, 10)
-    })
-  })
-})

package/dist/_hooks/__tests__/Hotkey.test.js

@@ -1,18 +0,0 @@
-import { fireEvent } from '@testing-library/react'
-import { act, renderHook } from '@testing-library/react-hooks'
-
-import { useHotkey } from '../Hotkey'
-
-describe('useHotkey', () => {
-  it('binds key handlers', () => {
-    const onSubmit = jest.fn()
-
-    renderHook(() => useHotkey({ key: 'Enter', handler: onSubmit }))
-
-    act(() => {
-      fireEvent.keyDown(window, { key: 'Enter' })
-      fireEvent.keyDown(window, { key: 'Enter' })
-      expect(onSubmit).toHaveBeenCalledTimes(2)
-    })
-  })
-})

package/dist/_hooks/__tests__/InjectedScript.test.js

@@ -1,80 +0,0 @@
-import {
-  testContext,
-  testHook,
-  testRenderProp,
-} from '../../__tests__/helpers/state'
-import {
-  InjectedScript,
-  InjectedScriptProvider,
-  useInjectedScript,
-  useInjectedScriptContext,
-} from '../InjectedScript'
-
-const validateAPI = (api) => {
-  expect(api.isLoaded).toEqual(false)
-  expect(api.setLoaded).toBeInstanceOf(Function)
-}
-
-const apiTest = {
-  test: 'api',
-  config: {
-    id: 'foo',
-    src: 'bar',
-  },
-  callback: validateAPI,
-}
-
-const configTest = {
-  test: 'config',
-  config: {
-    id: 'foo',
-    src: 'bar',
-  },
-  callback: ({ id, src }) => {
-    expect(id).toEqual(id)
-    expect(src).toEqual(src)
-  },
-}
-
-beforeEach(() => {
-  document.head.innerHTML = ''
-})
-
-describe('InjectedScript', () => {
-  testHook(useInjectedScript, [
-    apiTest,
-    configTest,
-    {
-      test: 'mutations',
-      config: {},
-      mutations: [
-        ['setLoaded', true, ['isLoaded', 'toBe', true]],
-        ['setLoaded', false, ['isLoaded', 'toBe', false]],
-      ],
-    },
-  ])
-
-  testRenderProp(InjectedScript, 'injectedScript', [apiTest, configTest])
-
-  testContext(InjectedScriptProvider, useInjectedScriptContext, [
-    apiTest,
-    configTest,
-    {
-      test: 'missing provider',
-      config: {},
-      injectProvider: false,
-      callback: (context, { spy }) => {
-        spy.mockImplementation(() => {})
-
-        expect(context.isLoaded).toBe(false)
-        context.setLoaded()
-        expect(spy).toBeCalledTimes(1)
-        expect(spy).toBeCalledWith(
-          'Could not call `setLoaded`, please wrap your component in a `<InjectedScriptProvider>`'
-        )
-
-        spy.mockRestore()
-      },
-    },
-  ])
-})

package/dist/_hooks/__tests__/ListNavigation.test.js

@@ -1,101 +0,0 @@
-import {
-  testContext,
-  testHook,
-  testRenderProp,
-} from '../../__tests__/helpers/state'
-import {
-  ListNavigation,
-  ListNavigationProvider,
-  useListNavigation,
-  useListNavigationContext,
-} from '../ListNavigation'
-
-const validateAPI = (api) => {
-  expect(api.index).toEqual(0)
-  expect(api.set).toBeInstanceOf(Function)
-  expect(api.increment).toBeInstanceOf(Function)
-  expect(api.decrement).toBeInstanceOf(Function)
-  expect(api.clear).toBeInstanceOf(Function)
-}
-
-const apiTest = {
-  test: 'api',
-  config: {},
-  callback: validateAPI,
-}
-
-const configTest = {
-  test: 'config',
-  config: { initialIndex: 3 },
-  callback: ({ index }) => expect(index).toEqual(3),
-}
-
-const spy = jest.spyOn(global.console, 'warn')
-beforeEach(() => {
-  spy.mockReset()
-})
-
-describe('ListNavigation', () => {
-  testHook(useListNavigation, [
-    apiTest,
-    configTest,
-    {
-      test: 'mutations',
-      config: { size: 5, initialIndex: -1 },
-      mutations: [
-        ['set', 3, ['index', 'toBe', 3]],
-        ['increment', null, ['index', 'toBe', 4]],
-        ['decrement', null, ['index', 'toBe', 3]],
-        ['clear', null, ['index', 'toBe', 0]],
-        ['set', 3, ['index', 'toBe', 3]],
-        ['decrementBy', 2, ['index', 'toBe', 1]],
-        ['incrementBy', 3, ['index', 'toBe', 4]],
-        ['reset', null, ['index', 'toBe', 0]],
-      ],
-    },
-    {
-      test: 'is circular',
-      config: { circular: true, initialIndex: 4, size: 5 },
-      mutations: [
-        ['increment', null, ['index', 'toBe', 0]],
-        ['decrement', null, ['index', 'toBe', 4]],
-      ],
-    },
-    {
-      test: 'is not circular, does not increment past size',
-      config: { circular: false, initialIndex: 5, size: 6 },
-      mutations: [['increment', null, ['index', 'toBe', 5]]],
-    },
-    {
-      test: 'is not circular, does not have a size, can decrement',
-      config: { circular: false, initialIndex: 100, size: 200 },
-      mutations: [['decrement', null, ['index', 'toBe', 99]]],
-    },
-    {
-      test: 'is not circular, does not have a size, can increment',
-      config: { circular: false, initialIndex: 100, size: 200 },
-      mutations: [['increment', null, ['index', 'toBe', 101]]],
-    },
-  ])
-
-  testRenderProp(ListNavigation, 'listNavigation', [apiTest, configTest])
-
-  testContext(ListNavigationProvider, useListNavigationContext, [
-    apiTest,
-    configTest,
-    {
-      test: 'missing provider',
-      config: {},
-      injectProvider: false,
-      callback: (context, { spy }) => {
-        expect(context.index).toBe(-1)
-        context.set()
-        context.increment()
-        context.decrement()
-        context.clear()
-        context.reset()
-        expect(spy).toBeCalledTimes(5)
-      },
-    },
-  ])
-})

package/dist/_hooks/__tests__/TextEntry.test.js

@@ -1,92 +0,0 @@
-import {
-  testContext,
-  testHook,
-  testRenderProp,
-} from '../../__tests__/helpers/state'
-import {
-  TextEntry,
-  TextEntryProvider,
-  useTextEntry,
-  useTextEntryContext,
-} from '../TextEntry'
-
-const validateAPI = (api) => {
-  expect(api.value).toEqual('')
-  expect(api.empty).toEqual(true)
-  expect(api.onChange).toBeInstanceOf(Function)
-  expect(api.clear).toBeInstanceOf(Function)
-  expect(api.reset).toBeInstanceOf(Function)
-}
-
-const apiTest = {
-  test: 'api',
-  config: {},
-  callback: validateAPI,
-}
-
-const configTest = {
-  test: 'config',
-  config: { initialValue: 'foo', handler: jest.fn() },
-  callback: ({ value }) => expect(value).toEqual('foo'),
-}
-
-const onChangeTest = () => {
-  const onChange = jest.fn()
-
-  return {
-    test: 'handler',
-    config: { onChange },
-    callback: ({ reset }) => {
-      reset()
-      expect(onChange).toBeCalled()
-    },
-  }
-}
-
-describe('TextEntry', () => {
-  testHook(useTextEntry, [
-    apiTest,
-    configTest,
-    onChangeTest(),
-    {
-      test: 'mutations',
-      config: { initialValue: 'foo' },
-      mutations: [
-        ['clear', null, ['value', 'toBe', '']],
-        ['reset', null, ['value', 'toBe', 'foo']],
-        ['reset', null, ['empty', 'toBe', false]],
-      ],
-    },
-  ])
-
-  testRenderProp(TextEntry, 'textEntry', [apiTest, configTest])
-
-  testContext(TextEntryProvider, useTextEntryContext, [
-    apiTest,
-    configTest,
-    {
-      test: 'missing provider',
-      config: {},
-      injectProvider: false,
-      callback: (context, { spy }) => {
-        spy.mockImplementation(() => {})
-
-        context.clear()
-        context.reset()
-        expect(spy).toBeCalledTimes(2)
-        expect(spy).toHaveBeenNthCalledWith(
-          1,
-          'Could not call `clear`, please wrap your component in a `<TextEntryProvider>`'
-        )
-        expect(spy).toHaveBeenNthCalledWith(
-          2,
-          'Could not call `reset`, please wrap your component in a `<TextEntryProvider>`'
-        )
-        expect(context.value).toBe('')
-        expect(context.empty).toBe(true)
-
-        spy.mockRestore()
-      },
-    },
-  ])
-})

package/dist/_hooks/__tests__/Timer.test.js

@@ -1,60 +0,0 @@
-import { mount } from 'enzyme'
-import React from 'react'
-import {
-  Component,
-  getProps,
-  testContext,
-  testHook,
-  testRenderProp,
-} from '../../__tests__/helpers/state'
-import { Timer, TimerProvider, useTimer, useTimerContext } from '../Timer'
-
-const validateAPI = (api) => {
-  expect(api.setTimer).toBeInstanceOf(Function)
-}
-
-const apiTest = {
-  test: 'api',
-  config: {},
-  callback: validateAPI,
-}
-
-describe('Timer', () => {
-  it('calls the provided function after the given time', (done) => {
-    const Enhanced = () => <Component {...useTimer()} />
-    const dom = mount(<Enhanced />)
-    const props = getProps(Component, dom)()
-    const spy = jest.fn()
-    props.setTimer(spy, 1000)
-    expect(spy).toBeCalledTimes(0)
-    setTimeout(() => {
-      expect(spy).toBeCalledTimes(1)
-      done()
-    }, 1500)
-  })
-
-  testHook(useTimer, [apiTest])
-
-  testRenderProp(Timer, 'timer', [apiTest])
-
-  testContext(TimerProvider, useTimerContext, [
-    apiTest,
-    {
-      test: 'missing provider',
-      config: {},
-      injectProvider: false,
-      callback: (context, { spy }) => {
-        spy.mockImplementation(() => {})
-
-        expect(context.timerId).toBe(null)
-        context.setTimer()
-        expect(spy).toBeCalledTimes(1)
-        expect(spy).toBeCalledWith(
-          'Could not call `setTimer`, please wrap your component in a `<TimerProvider>`'
-        )
-
-        spy.mockRestore()
-      },
-    },
-  ])
-})

package/dist/_hooks/__tests__/Trigger.test.js

@@ -1,52 +0,0 @@
-import React from 'react'
-import {
-  testContext,
-  testHook,
-  testRenderProp,
-} from '../../__tests__/helpers/state'
-import {
-  initTrigger,
-  Trigger,
-  TriggerProvider,
-  useTrigger,
-  useTriggerContext,
-} from '../Trigger'
-
-const mockEnable = () => {}
-const mockDisable = () => {}
-
-const validateAPI = (api) => {
-  expect(api.isVisible).toBe(false)
-  expect(api.enable).toBeInstanceOf(Function)
-  expect(api.disable).toBeInstanceOf(Function)
-  expect(api.toggle).toBeInstanceOf(Function)
-}
-
-const apiTest = {
-  test: 'api',
-  config: {
-    scope: React.createRef(),
-    enable: mockEnable,
-    disable: mockDisable,
-  },
-  callback: validateAPI,
-}
-
-describe('Trigger', () => {
-  testHook(useTrigger, [apiTest])
-
-  testRenderProp(Trigger, 'trigger', [apiTest])
-
-  testContext(TriggerProvider, useTriggerContext, [
-    apiTest,
-    ,
-    {
-      test: 'missing provider',
-      config: {},
-      injectProvider: false,
-      callback: (context) => {
-        expect(context).toEqual(initTrigger)
-      },
-    },
-  ])
-})