@procore/core-react 11.25.1 → 11.25.2

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

@@ -1,86 +0,0 @@
-import {
-  testContext,
-  testHook,
-  testRenderProp,
-} from '../../__tests__/helpers/state'
-import {
-  useVisibility,
-  useVisibilityContext,
-  Visibility,
-  VisibilityProvider,
-} from '../Visibility'
-
-const validateAPI = (api) => {
-  expect(api.isVisible).toEqual(false)
-  expect(api.show).toBeInstanceOf(Function)
-  expect(api.hide).toBeInstanceOf(Function)
-  expect(api.toggle).toBeInstanceOf(Function)
-}
-
-const apiTest = {
-  test: 'api',
-  config: {},
-  callback: validateAPI,
-}
-
-const configTest = {
-  test: 'config',
-  config: {
-    initialIsVisible: true,
-  },
-  callback: ({ isVisible }) => {
-    expect(isVisible).toEqual(true)
-  },
-}
-
-describe('Visibility', () => {
-  testHook(useVisibility, [
-    apiTest,
-    configTest,
-    {
-      test: 'mutations',
-      config: {},
-      mutations: [
-        ['show', null, ['isVisible', 'toBe', true]],
-        ['hide', null, ['isVisible', 'toBe', false]],
-        ['toggle', null, ['isVisible', 'toBe', true]],
-        ['toggle', null, ['isVisible', 'toBe', false]],
-      ],
-    },
-  ])
-
-  testRenderProp(Visibility, 'visibility', [apiTest, configTest])
-
-  testContext(VisibilityProvider, useVisibilityContext, [
-    apiTest,
-    configTest,
-    {
-      test: 'missing provider',
-      config: {},
-      injectProvider: false,
-      callback: (context, { spy }) => {
-        spy.mockImplementation(() => {})
-
-        expect(context.isVisible).toBe(false)
-        context.show()
-        context.hide()
-        context.toggle()
-        expect(spy).toBeCalledTimes(3)
-        expect(spy).toHaveBeenNthCalledWith(
-          1,
-          'Could not call `show`, please wrap your component in a `<VisibilityProvider>`'
-        )
-        expect(spy).toHaveBeenNthCalledWith(
-          2,
-          'Could not call `hide`, please wrap your component in a `<VisibilityProvider>`'
-        )
-        expect(spy).toHaveBeenNthCalledWith(
-          3,
-          'Could not call `toggle`, please wrap your component in a `<VisibilityProvider>`'
-        )
-
-        spy.mockRestore()
-      },
-    },
-  ])
-})

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

@@ -1,76 +0,0 @@
-import {
-  testContext,
-  testHook,
-  testRenderProp,
-} from '../../__tests__/helpers/state'
-import {
-  defaultZIndex,
-  useZIndex,
-  useZIndexContext,
-  ZIndex,
-  ZIndexProvider,
-} from '../ZIndex'
-
-const validateAPI = (api) => {
-  expect(api.value).toEqual(defaultZIndex)
-  expect(api.increment).toBeInstanceOf(Function)
-}
-
-const apiTest = {
-  test: 'api',
-  config: {},
-  callback: validateAPI,
-}
-
-const configTest = {
-  test: 'config',
-  config: { initialValue: 10 },
-  callback: ({ value }) => expect(value).toEqual(10),
-}
-
-describe('ZIndex', () => {
-  testHook(useZIndex, [
-    apiTest,
-    configTest,
-    {
-      test: 'mutations',
-      config: {},
-      mutations: [['increment', null, ['value', 'toBe', defaultZIndex + 1]]],
-    },
-  ])
-
-  testRenderProp(ZIndex, 'zIndex', [apiTest, configTest])
-
-  testContext(ZIndexProvider, useZIndexContext, [
-    {
-      test: 'api',
-      config: {},
-      callback: (api) => {
-        expect(api.value).toEqual(defaultZIndex + 1)
-        expect(api.increment).toBeInstanceOf(Function)
-      },
-    },
-    {
-      test: 'config',
-      config: { initialValue: 10 },
-      callback: ({ value }) => expect(value).toEqual(11),
-    },
-    {
-      test: 'missing provider',
-      config: {},
-      injectProvider: false,
-      callback: (context, { spy }) => {
-        spy.mockImplementation(() => {})
-
-        expect(context.value).toBe(defaultZIndex + 1)
-        context.increment()
-        expect(spy).toBeCalledTimes(1)
-        expect(spy).toBeCalledWith(
-          'Could not call `increment`, please wrap your component in a `<ZIndexProvider>`'
-        )
-
-        spy.mockRestore()
-      },
-    },
-  ])
-})

package/dist/_utils/__tests__/CalendarHelpers.test.js

@@ -1,64 +0,0 @@
-import { addDays, getDay, startOfMonth, subDays } from 'date-fns'
-import {
-  daysInCalendar,
-  getDates,
-  getDayOfWeekLabel,
-  getMonthLabel,
-} from '../CalendarHelpers'
-
-describe('getDates', () => {
-  it('should always have a length of daysInCalendar days', () => {
-    const dateArray = getDates(new Date('2019-01-17'))
-    expect(dateArray.length).toBe(daysInCalendar)
-  })
-
-  it('has the right start date', () => {
-    const date = new Date('2019-2-2')
-    const dateArray = getDates(date)
-    const startDate = subDays(startOfMonth(date), getDay(startOfMonth(date)))
-    expect(dateArray[0]).toEqual(startDate)
-  })
-
-  it('has the right end date', () => {
-    const date = new Date('2019-2-2')
-    const dateArray = getDates(date)
-    const startDate = subDays(startOfMonth(date), getDay(startOfMonth(date)))
-    const endDate = addDays(startDate, daysInCalendar - 1)
-    expect(dateArray[daysInCalendar - 1]).toEqual(endDate)
-  })
-
-  it('in january, previous month days come from december of previous year', () => {
-    const date = new Date('2019-01-02')
-    const dateArray = getDates(date)
-    expect(dateArray[0].getMonth()).toBe(11)
-    expect(date.getFullYear() - dateArray[0].getFullYear()).toBe(1)
-  })
-
-  it('in december, next month days come from january of next year', () => {
-    const date = new Date('2019-12-25')
-    const dateArray = getDates(date)
-    const lastDay = dateArray[daysInCalendar - 1]
-    expect(lastDay.getMonth()).toBe(0)
-    expect(lastDay.getFullYear() - date.getFullYear()).toBe(1)
-  })
-
-  it('is Jan month label', () => {
-    const label = getMonthLabel(0, 'en-US')
-    expect(label).toBe('Jan')
-  })
-
-  it('is Jun month label', () => {
-    const label = getMonthLabel(5, 'en-US')
-    expect(label).toBe('Jun')
-  })
-
-  it('is janv month label (fr)', () => {
-    const label = getMonthLabel(0, 'fr-FR')
-    expect(label).toBe('janv.')
-  })
-
-  it('day of week (fr)', () => {
-    const label = getDayOfWeekLabel(0, 'fr-FR')
-    expect(label).toBe('di')
-  })
-})

package/dist/_utils/__tests__/filename.test.js

@@ -1,27 +0,0 @@
-import { getFileExtension, parseFilename } from '../filename'
-
-describe('parseFilename', () => {
-  it('should parse file name', () => {
-    expect(parseFilename('a.png')).toEqual({
-      filename: 'a',
-      extension: 'png',
-      isFilename: true,
-    })
-  })
-
-  it('should handle non-filename strings', () => {
-    expect(parseFilename('abcd-efg-hij')).toEqual({
-      filename: '',
-      extension: '',
-      isFilename: false,
-    })
-  })
-})
-
-describe('getFileExtension', () => {
-  it('should return file extension from a string', () => {
-    expect(getFileExtension('a.png')).toEqual('png')
-    expect(getFileExtension('abcd.jpg.png')).toEqual('png')
-    expect(getFileExtension('abcd')).toEqual('')
-  })
-})

package/dist/_utils/__tests__/getAnchorPosition.test.js

@@ -1,250 +0,0 @@
-import {
-  getAlignmentPosition,
-  getAnchorPosition,
-  getEdgePosition,
-} from '../getAnchorPosition'
-
-// TEST UTILS
-// ==========
-
-const getBox = (shape, position = { left: 0, top: 0 }) => ({
-  ...position,
-  ...shape,
-  right: shape.width + position.left,
-  bottom: shape.height + position.top,
-})
-
-const Dimensions = {
-  target: { width: 100, height: 100 },
-  overlay: { width: 400, height: 400 },
-  container: { width: 1000, height: 1000 },
-}
-
-const Positions = {
-  topLeft: { left: 200, top: 200 },
-  bottomLeft: { left: 200, top: 800 },
-  bottomRight: { left: 800, top: 800 },
-  topRight: { left: 800, top: 200 },
-}
-
-const Targets = {
-  topLeft: getBox(Dimensions.target, Positions.topLeft),
-  topRight: getBox(Dimensions.target, Positions.topRight),
-  bottomRight: getBox(Dimensions.target, Positions.bottomRight),
-  bottomLeft: getBox(Dimensions.target, Positions.bottomLeft),
-}
-
-describe('getAnchorPosition', () => {
-  const container = getBox(Dimensions.container)
-  const overlay = getBox(Dimensions.overlay)
-
-  it('places an overlay around a contained target', () => {
-    const target = Targets.topLeft
-    const position = getAnchorPosition(
-      'bottom-left',
-      0,
-      container,
-      target,
-      overlay
-    )
-    expect(position.left).toBe(target.left)
-    expect(position.top).toBe(target.bottom)
-  })
-
-  it('flips placement components as needed', () => {
-    const target = Targets.bottomRight
-    const position = getAnchorPosition(
-      'bottom-left',
-      0,
-      container,
-      target,
-      overlay
-    )
-    expect(position.left).toBe(target.right - overlay.width)
-    expect(position.top).toBe(target.top - overlay.height)
-  })
-
-  describe('Adjusts position according to padding', () => {
-    const target = Targets.bottomLeft
-    const edgePadding = 10
-    const position = getAnchorPosition(
-      'top-left',
-      edgePadding,
-      container,
-      target,
-      overlay
-    )
-    it('adds edge padding', () => {
-      expect(position.top).toBe(target.top - overlay.height - edgePadding)
-    })
-    it('does NOT add alignment padding', () => {
-      expect(position.left).toBe(target.left)
-    })
-  })
-
-  describe('anchors to side or flip if necessary', () => {
-    it('anchors left', () => {
-      const target = Targets.topRight
-      const position = getEdgePosition({
-        container,
-        target,
-        overlay,
-        placement: 'left',
-      })
-      expect(position.left).toBe(target.left - overlay.width)
-    })
-    it('it anchors right when it should flip(left)', () => {
-      const target = Targets.topLeft
-      const position = getEdgePosition({
-        container,
-        target,
-        overlay,
-        placement: 'left',
-      })
-      expect(position.left).toBe(target.right)
-    })
-    it('anchors right', () => {
-      const target = Targets.topLeft
-      const position = getEdgePosition({
-        container,
-        target,
-        overlay,
-        placement: 'right',
-      })
-      expect(position.left).toBe(target.right)
-    })
-    it('it anchors left when it should flip(right)', () => {
-      const target = Targets.topRight
-      const position = getEdgePosition({
-        container,
-        target,
-        overlay,
-        placement: 'right',
-      })
-      expect(position.left).toBe(target.left - overlay.width)
-    })
-    it('anchors top', () => {
-      const target = Targets.bottomLeft
-      const position = getEdgePosition({
-        container,
-        target,
-        overlay,
-        placement: 'top',
-      })
-      expect(position.top).toBe(target.top - overlay.height)
-    })
-    it('it anchors bottom when it should flip(top)', () => {
-      const target = Targets.topLeft
-      const position = getEdgePosition({
-        container,
-        target,
-        overlay,
-        placement: 'top',
-      })
-      expect(position.top).toBe(target.bottom)
-    })
-    it('anchors bottom', () => {
-      const target = Targets.topRight
-      const position = getEdgePosition({
-        container,
-        target,
-        overlay,
-        placement: 'bottom',
-      })
-      expect(position.top).toBe(target.bottom)
-    })
-    it('it anchors top when it should flip(bottom)', () => {
-      const target = Targets.bottomLeft
-      const position = getEdgePosition({
-        container,
-        target,
-        overlay,
-        placement: 'bottom',
-      })
-      expect(position.top).toBe(target.top - overlay.height)
-    })
-  })
-  describe('align horizontally/vertically or flip if necessary', () => {
-    it('aligns left', () => {
-      const target = Targets.topLeft
-      const position = getAlignmentPosition({
-        container,
-        target,
-        overlay,
-        placement: 'left',
-      })
-      expect(position.left).toBe(target.left)
-    })
-    it('it aligns right when it should flip(left)', () => {
-      const target = Targets.topRight
-      const position = getAlignmentPosition({
-        container,
-        target,
-        overlay,
-        placement: 'left',
-      })
-      expect(position.left + overlay.width).toBe(target.right)
-    })
-    it('aligns right', () => {
-      const target = Targets.topRight
-      const position = getAlignmentPosition({
-        container,
-        target,
-        overlay,
-        placement: 'right',
-      })
-      expect(position.left + overlay.width).toBe(target.right)
-    })
-    it('it aligns left when it should flip(right)', () => {
-      const target = Targets.topLeft
-      const position = getAlignmentPosition({
-        container,
-        target,
-        overlay,
-        placement: 'right',
-      })
-      expect(position.left).toBe(target.left)
-    })
-
-    it('aligns top', () => {
-      const target = Targets.topLeft
-      const position = getAlignmentPosition({
-        container,
-        target,
-        overlay,
-        placement: 'top',
-      })
-      expect(position.top).toBe(target.top)
-    })
-    it('it aligns bottom when it should flip(top)', () => {
-      const target = Targets.bottomLeft
-      const position = getAlignmentPosition({
-        container,
-        target,
-        overlay,
-        placement: 'top',
-      })
-      expect(position.top + overlay.height).toBe(target.bottom)
-    })
-    it('aligns bottom', () => {
-      const target = Targets.bottomLeft
-      const position = getAlignmentPosition({
-        container,
-        target,
-        overlay,
-        placement: 'bottom',
-      })
-      expect(position.top + overlay.height).toBe(target.bottom)
-    })
-    it('it aligns top when it should flip(bottom)', () => {
-      const target = Targets.topRight
-      const position = getAlignmentPosition({
-        container,
-        target,
-        overlay,
-        placement: 'bottom',
-      })
-      expect(position.top).toBe(target.top)
-    })
-  })
-})

package/dist/_utils/__tests__/mergeRefs.test.js

@@ -1,58 +0,0 @@
-import { mount } from 'enzyme'
-import React from 'react'
-import { assignRef, mergeRefs } from '../mergeRefs'
-
-const refValue = 'ref'
-
-describe('assignRef', () => {
-  it('should call callback ref with value', () => {
-    const refAsFunc = jest.fn()
-    assignRef(refAsFunc, refValue)
-
-    expect(refAsFunc).toHaveBeenCalledTimes(1)
-    expect(refAsFunc).toHaveBeenCalledWith(refValue)
-  })
-
-  it('should assign value to ref object', () => {
-    const refAsObj = { current: undefined }
-    assignRef(refAsObj, refValue)
-
-    expect(refAsObj.current).toBe(refValue)
-  })
-
-  it('should ignore when ref equals null', () => {
-    const refAsObj = null
-    assignRef(refAsObj, refValue)
-
-    expect(refAsObj).toBe(null)
-  })
-})
-
-test('mergeRefs', () => {
-  const Dummy = React.forwardRef((_, forwardRef) => {
-    React.useImperativeHandle(forwardRef, () => refValue)
-    return null
-  })
-
-  const refAsFunc = jest.fn()
-  const refAsObj = { current: undefined }
-
-  const Example = ({ visible }) => {
-    if (visible) {
-      return <Dummy ref={mergeRefs(refAsFunc, refAsObj)} />
-    }
-    return null
-  }
-
-  const wrapper = mount(<Example visible />)
-
-  expect(refAsFunc).toHaveBeenCalledTimes(1)
-  expect(refAsFunc).toHaveBeenCalledWith(refValue)
-  expect(refAsObj.current).toBe(refValue)
-
-  wrapper.setProps({ visible: false })
-
-  expect(refAsFunc).toHaveBeenCalledTimes(2)
-  expect(refAsFunc).toHaveBeenCalledWith(null)
-  expect(refAsObj.current).toBe(null)
-})

package/dist/_utils/__tests__/slotify.test.js

@@ -1,152 +0,0 @@
-import React from 'react'
-
-import { slotify } from '../slotify'
-
-const Foo = React.forwardRef(function Foo() {
-  return <div />
-})
-const Bar = React.forwardRef(function Bar() {
-  return <div />
-})
-const Baz = React.forwardRef(function Baz() {
-  return <div />
-})
-const Unexpected = React.forwardRef(function Fatal() {
-  return <div />
-})
-
-describe('slotify', () => {
-  it('should display slot children if encountered', () => {
-    const slots = slotify(
-      [
-        <Foo>
-          <div id="foo-child" />
-        </Foo>,
-        <Bar>
-          <div id="bar-child" />
-        </Bar>,
-        <Baz bazattr="xyz" />,
-      ],
-      {
-        foo: Foo,
-        bar: Bar,
-      }
-    )
-
-    expect(slots).toEqual({
-      foo: {
-        slotProps: {},
-        slotRef: null,
-        slotChildren: <div id="foo-child" />,
-      },
-      bar: {
-        slotProps: {},
-        slotRef: null,
-        slotChildren: <div id="bar-child" />,
-      },
-    })
-  })
-
-  it('should display only those slots that are expected to see', () => {
-    const slots = slotify(
-      [
-        <Foo ref={{ fooref: true }} fooattr="123">
-          <div id="foo-child" />
-        </Foo>,
-        <Bar ref={{ barref: true }} barattr="abc">
-          <div id="bar-child" />
-        </Bar>,
-        <Unexpected />,
-      ],
-      {
-        foo: Foo,
-        bar: Bar,
-      }
-    )
-
-    expect(slots).toEqual({
-      foo: {
-        slotProps: {
-          fooattr: '123',
-        },
-        slotRef: {
-          fooref: true,
-        },
-        slotChildren: <div id="foo-child" />,
-      },
-      bar: {
-        slotProps: {
-          barattr: 'abc',
-        },
-        slotRef: {
-          barref: true,
-        },
-        slotChildren: <div id="bar-child" />,
-      },
-    })
-  })
-
-  it('should not display slots that are not encountered among the children', () => {
-    const slots = slotify(
-      [
-        <Foo>
-          <div id="foo-child" />
-        </Foo>,
-        <Bar>
-          <div />
-        </Bar>,
-        <Baz>
-          <div />
-        </Baz>,
-      ],
-      {
-        foo: Foo,
-      }
-    )
-
-    expect(slots).toEqual({
-      foo: {
-        slotProps: {},
-        slotRef: null,
-        slotChildren: <div id="foo-child" />,
-      },
-    })
-  })
-
-  it('should return slot props', () => {
-    const slots = slotify([<Foo fooattr="123" />], {
-      foo: Foo,
-    })
-
-    expect(slots.foo).toEqual({
-      slotProps: {
-        fooattr: '123',
-      },
-      slotRef: null,
-    })
-  })
-
-  it('should return slot ref', () => {
-    const slots = slotify([<Bar ref={{ barref: true }} />], {
-      bar: Bar,
-    })
-
-    expect(slots.bar).toEqual({
-      slotProps: {},
-      slotRef: {
-        barref: true,
-      },
-    })
-  })
-
-  it('should return empty props object if the slot container does not have props', () => {
-    const slots = slotify([<Baz />], {
-      baz: Baz,
-    })
-
-    expect(slots.baz).toEqual({
-      slotProps: {},
-      slotRef: null,
-    })
-  })
-})