level_0
int64 0
10k
| index
int64 0
0
| repo_id
stringlengths 22
152
| file_path
stringlengths 41
203
| content
stringlengths 11
11.5M
|
|---|---|---|---|---|
6,351 | 0 | petrpan-code/pmndrs/react-spring/packages/core/src | petrpan-code/pmndrs/react-spring/packages/core/src/hooks/useSpringValue.test.ts | import { renderHook } from '@testing-library/react'
import { useSpringValue } from './useSpringValue'
describe('useSpringValue', () => {
it('should return a SpringValue with the initial value set & be animatable', async () => {
const { result } = renderHook(() => useSpringValue(0))
expect(result.current.get()).toBe(0)
result.current.start(1)
await global.advanceUntilIdle()
const frames = global.getFrames(result.current)
expect(frames).toMatchInlineSnapshot(`
[
0.022634843307857987,
0.07615528894993949,
0.14727295456877587,
0.226793329378144,
0.30850531916036833,
0.3883524421610094,
0.4638171205392546,
0.5334657448036914,
0.5966146523130327,
0.653086718031782,
0.7030355736424124,
0.7468200657416287,
0.7849158337229618,
0.8178541406742544,
0.84618056340198,
0.8704280232770599,
0.8911000586164687,
0.908661309883985,
0.9235329941206051,
0.9360917483504706,
0.9466706719880811,
0.9555617327559859,
0.9630189477450245,
0.9692619326731112,
0.974479544590839,
0.9788334387327177,
0.9824614283710769,
0.9854805845242963,
0.9879900455631954,
0.9900735291663613,
0.9918015536949567,
0.9932333851170554,
0.9944187307560263,
0.9953992035746594,
0.9962095813165257,
0.9968788842438258,
0.9974312938902624,
0.997886933507673,
0.9982625289470638,
0.9985719667273453,
0.9988267641056736,
1,
]
`)
})
it('should pass the props to the SpringValue', async () => {
const onChange = jest.fn()
const { result: spring1Result } = renderHook(() =>
useSpringValue(0, {
onChange,
config: {
tension: 250,
},
})
)
spring1Result.current.start(1)
await global.advanceUntilIdle()
const spring1Frames = global.getFrames(spring1Result.current)
expect(onChange).toHaveBeenCalledTimes(spring1Frames.length)
expect(spring1Frames).toMatchInlineSnapshot(`
[
0.03322035282414196,
0.11115235982150365,
0.2130842922652568,
0.32437365472020624,
0.4351150247228329,
0.5390109579648729,
0.6324388770927332,
0.7136979238346725,
0.7824149821427263,
0.8390872502255999,
0.8847388969420807,
0.9206707563299439,
0.948284154761085,
0.9689624419925535,
0.983996343637665,
0.9945416938864688,
1.0016003383581966,
1.006016962813285,
1.008486284526941,
1.009566443632207,
1.0096955708194038,
1.0092094129953517,
1.0083586011904877,
1.00732467705411,
1.0062343860893856,
1.0051720249961695,
1.0041898213810294,
1.0033164473489222,
1.0025638412971623,
1.0019325485312394,
1.001415802163774,
1.0010025596964731,
1,
]
`)
const { result: spring2Result } = renderHook(() => useSpringValue(0))
spring2Result.current.start(1)
await global.advanceUntilIdle()
const spring2Frames = global.getFrames(spring2Result.current)
expect(spring2Frames).not.toEqual(spring1Frames)
})
it('should not update the initial value on rerender', () => {
const { result, rerender } = renderHook(props => useSpringValue(props), {
initialProps: 0,
})
expect(result.current.get()).toBe(0)
rerender(1)
expect(result.current.get()).toBe(0)
})
it('should stop the animation when the hook is unmounted', async () => {
const { result, unmount } = renderHook(() => useSpringValue(0))
const promise = result.current.start(1)
await global.advanceUntilValue(result.current, 0.5)
unmount()
await global.advanceUntilIdle()
expect((await promise).value).toMatchInlineSnapshot(`0.5334657448036914`)
})
})
|
6,353 | 0 | petrpan-code/pmndrs/react-spring/packages/core/src | petrpan-code/pmndrs/react-spring/packages/core/src/hooks/useSprings.test.tsx | import * as React from 'react'
import { render, RenderResult } from '@testing-library/react'
import { is, eachProp } from '@react-spring/shared'
import { Lookup } from '@react-spring/types'
import { SpringRef } from '../SpringRef'
import { SpringValue } from '../SpringValue'
import { useSprings } from './useSprings'
describe('useSprings', () => {
const isStrictMode = true
const strictModeFunctionCallMultiplier = isStrictMode ? 2 : 1
let springs: Lookup<SpringValue>[]
let ref: SpringRef
// Call the "useSprings" hook and update local variables.
const update = createUpdater(({ args }) => {
const result = useSprings(...args)
if (is.fun(args[1]) || args.length == 3) {
springs = result[0] as any
ref = result[1]
} else {
springs = result as any
ref = undefined as any
}
return null
}, isStrictMode)
describe('when only a props function is passed', () => {
it('calls the props function once per new spring', () => {
const getProps = jest.fn((i: number) => ({ x: i * 100 }))
// Create two springs.
update(2, getProps)
expect(getProps).toHaveBeenCalledTimes(
2 * strictModeFunctionCallMultiplier
)
expect(springs.length).toBe(2)
expect(ref.current.length).toBe(2)
// Do nothing.
update(2, getProps)
expect(getProps).toHaveBeenCalledTimes(
2 * strictModeFunctionCallMultiplier
)
expect(springs.length).toBe(2)
expect(ref.current.length).toBe(2)
// Create a spring.
update(3, getProps)
expect(getProps).toHaveBeenCalledTimes(
3 * strictModeFunctionCallMultiplier
)
expect(springs.length).toBe(3)
expect(ref.current.length).toBe(3)
// Remove a spring.
update(2, getProps)
expect(getProps).toHaveBeenCalledTimes(
3 * strictModeFunctionCallMultiplier
)
expect(springs.length).toBe(2)
expect(ref.current.length).toBe(2)
// Create two springs.
update(4, getProps)
expect(getProps).toHaveBeenCalledTimes(
5 * strictModeFunctionCallMultiplier
)
expect(springs.length).toBe(4)
expect(ref.current.length).toBe(4)
})
})
describe('when both a props function and a deps array are passed', () => {
it('updates each spring when the deps have changed', () => {
const getProps = jest.fn((i: number) => ({ x: i * 100 }))
update(2, getProps, [1])
expect(getProps).toHaveBeenCalledTimes(
2 * strictModeFunctionCallMultiplier
)
update(2, getProps, [1])
expect(getProps).toHaveBeenCalledTimes(
2 * strictModeFunctionCallMultiplier
)
update(2, getProps, [2])
expect(getProps).toHaveBeenCalledTimes(
4 * strictModeFunctionCallMultiplier
)
})
})
describe('when only a props array is passed', () => {
it('updates each spring on every render', () => {
update(2, [{ x: 0 }, { x: 0 }])
expect(mapSprings(s => s.goal)).toEqual([{ x: 0 }, { x: 0 }])
update(3, [{ x: 1 }, { x: 2 }, { x: 3 }])
expect(mapSprings(s => s.goal)).toEqual([{ x: 1 }, { x: 2 }, { x: 3 }])
})
})
describe('when the length argument increases', () => {
it('creates new springs', () => {
const getProps = (i: number) => ({ x: i * 100 })
update(0, getProps, [[]])
expect(springs.length).toBe(0)
expect(ref.current.length).toBe(0)
update(2, getProps, [[1, 2]])
expect(springs.length).toBe(2)
expect(ref.current.length).toBe(2)
update(0, getProps, [[]])
expect(springs.length).toBe(0)
expect(ref.current.length).toBe(0)
update(2, getProps, [[1, 2]])
expect(springs.length).toBe(2)
expect(ref.current.length).toBe(2)
update(1, getProps, [[1]])
expect(springs.length).toBe(1)
expect(ref.current.length).toBe(1)
update(2, getProps, [[1, 2]])
expect(springs.length).toBe(2)
expect(ref.current.length).toBe(2)
})
})
describe('when the length argument decreases', () => {
it('removes old springs', () => {
const getProps = (i: number) => ({ x: i * 100 })
update(3, getProps)
expect(springs.length).toBe(3)
expect(ref.current.length).toBe(3)
update(1, getProps)
expect(springs.length).toBe(1)
expect(ref.current.length).toBe(1)
update(3, getProps)
expect(springs.length).toBe(3)
expect(ref.current.length).toBe(3)
update(1, getProps)
expect(springs.length).toBe(1)
expect(ref.current.length).toBe(1)
})
})
function mapSprings<T>(fn: (spring: SpringValue) => T) {
return springs.map(values => {
const result: any = {}
eachProp(values, spring => {
result[spring.key!] = fn(spring)
})
return result
})
}
})
function createUpdater(
Component: React.ComponentType<{ args: [any, any, any?] }>,
isStrictMode: boolean
) {
let result: RenderResult | undefined
afterEach(() => {
result = undefined
})
type Args = [number, any[] | ((i: number) => any), any[]?]
return (...args: Args) => {
const component = <Component args={args} />
const elem = isStrictMode ? (
<React.StrictMode>{component}</React.StrictMode>
) : (
component
)
if (result) result.rerender(elem)
else result = render(elem)
return result
}
}
|
6,355 | 0 | petrpan-code/pmndrs/react-spring/packages/core/src | petrpan-code/pmndrs/react-spring/packages/core/src/hooks/useTrail.test.tsx | import * as React from 'react'
import { render, RenderResult } from '@testing-library/react'
import { is } from '@react-spring/shared'
import { Lookup } from '@react-spring/types'
import { SpringValue } from '../SpringValue'
import { useTrail, UseTrailProps } from './useTrail'
describe('useTrail', () => {
let springs: Lookup<SpringValue>[]
// Call the "useSprings" hook and update local variables.
const update = createUpdater(({ args }) => {
const result = useTrail(...args)
// @ts-expect-error - TODO: fix this type error.
springs = is.arr(result[0]) ? result[0] : result
return null
})
it('has each spring follow the spring before it', () => {
update(2, { x: 100, from: { x: 0 } })
expect(springs.length).toBe(2)
expect(springs[1].x.animation.to).toBe(springs[0].x)
global.mockRaf.step()
expect(springs[0].x.get()).not.toBe(springs[1].x.get())
})
describe('when a props object is passed', () => {
it('updates every spring on rerender', () => {
const props = { opacity: 1, config: { tension: 100 } }
update(2, props)
const configs = springs.map(s => s.opacity.animation.config)
expect(configs.every(config => config.tension == 100)).toBeTruthy()
props.config.tension = 50
update(2, props)
expect(configs.every(config => config.tension == 50)).toBeTruthy()
})
})
describe('when a props function is passed', () => {
it.todo('does nothing on rerender')
})
describe('with the "reverse" prop', () => {
describe('when "reverse" becomes true', () => {
it.todo('swaps the "to" and "from" props')
it.todo('has each spring follow the spring after it')
})
describe('when "reverse" becomes false', () => {
it.todo('uses the "to" and "from" props as-is')
it.todo('has each spring follow the spring before it')
})
})
})
function createUpdater(
Component: React.ComponentType<{ args: [any, any, any?] }>
) {
let result: RenderResult | undefined
afterEach(() => {
result = undefined
})
type Args = [number, UseTrailProps, any[]?]
return (...args: Args) => {
const elem = <Component args={args} />
if (result) result.rerender(elem)
else result = render(elem)
return result
}
}
|
6,357 | 0 | petrpan-code/pmndrs/react-spring/packages/core/src | petrpan-code/pmndrs/react-spring/packages/core/src/hooks/useTransition.test.tsx | import * as React from 'react'
import '@testing-library/jest-dom'
import { RenderResult, render } from '@testing-library/react'
import { toArray } from '@react-spring/shared'
import { TransitionFn, UseTransitionProps } from '../types'
import { useTransition } from './useTransition'
import { SpringRef } from '../SpringRef'
describe('useTransition', () => {
let transition: TransitionFn
let rendered: any[]
afterEach(() => {
result = undefined
})
// Call the "useTransition" hook and update local variables.
const update = createUpdater(({ args }) => {
transition = toArray(useTransition(...args))[0]
rendered = transition((_, item) => item).props.children
return null
})
it('unmounts after leave', async () => {
const props = {
from: { n: 0 },
enter: { n: 1 },
leave: { n: 0 },
}
update(true, props)
expect(rendered).toEqual([true])
global.mockRaf.step()
update(false, props)
expect(rendered).toEqual([true, false])
await global.advanceUntilIdle()
expect(rendered).toEqual([false])
})
describe('when "leave" is an array', () => {
it('unmounts after leave', async () => {
const props = {
from: { n: 0 },
enter: { n: 1 },
leave: [{ n: 0 }],
}
update(true, props)
expect(rendered).toEqual([true])
global.mockRaf.step()
update(false, props)
expect(rendered).toEqual([true, false])
await global.advanceUntilIdle()
expect(rendered).toEqual([false])
})
})
describe('when "leave" is a function', () => {
it('unmounts after leave', async () => {
const props: UseTransitionProps = {
from: { n: 0 },
enter: { n: 1 },
leave: () => async next => {
await next({ n: 0 })
},
}
update(true, props)
expect(rendered).toEqual([true])
global.mockRaf.step()
update(false, props)
expect(rendered).toEqual([true, false])
await global.advanceUntilIdle()
expect(rendered).toEqual([false])
})
})
describe('when "enter" is a function', () => {
it('still has its "onRest" prop called', async () => {
const onRest = jest.fn()
update(true, {
from: { x: 0 },
enter: () => ({
x: 1,
onRest,
}),
})
await global.advanceUntilIdle()
expect(onRest).toBeCalledTimes(1)
})
})
describe('when "leave" is a no-op update', () => {
it('still unmounts the transition', async () => {
const props = {
from: { t: 0 },
enter: { t: 1 },
leave: { t: 1 },
}
update(true, props)
expect(rendered).toEqual([true])
await global.advanceUntilIdle()
update(false, props)
expect(rendered).toEqual([true, false])
await global.advanceUntilIdle()
expect(rendered).toEqual([false])
})
})
it('assign controllers to provided "ref"', async () => {
const ref = SpringRef()
const props = {
ref,
}
const children = [<div key={1} />, <div key={2} />, <div key={3} />]
update(children, props)
expect(ref.current).toHaveLength(3)
testIsRef(ref)
})
it('returns a ref if the props argument is a function', () => {
let transRef: SpringRef | null = null
const update = createUpdater(({ args }) => {
const [transition, ref] = useTransition(...args)
rendered = transition((_, item) => item).props.children
transRef = ref
return null
})
update(true, () => ({
from: { n: 0 },
enter: { n: 1 },
leave: { n: 0 },
}))
expect(rendered).toEqual([true])
testIsRef(transRef)
})
it('passes immediate through to payload', async () => {
const props = {
from: { n: 0 },
enter: { n: 1 },
leave: { n: 0 },
immediate: true,
}
update(true, props)
transition(style => {
expect(style.n.animation.immediate).toEqual(true)
return null
})
})
it('should allow items to leave before entering new items when exitBeforeEnter is true', async () => {
const props = {
from: { t: 0 },
enter: { t: 1 },
leave: { t: 1 },
exitBeforeEnter: true,
}
update(0, props)
expect(rendered).toEqual([0])
global.mockRaf.step()
update(1, props)
global.mockRaf.step()
expect(rendered).toEqual([0])
await global.advanceUntilIdle()
expect(rendered).toEqual([1])
})
})
let result: RenderResult | undefined
function createUpdater(
Component: React.ComponentType<{ args: [any, any, any?] }>
) {
type Args = [any, UseTransitionProps | (() => UseTransitionProps), any[]?]
return (...args: Args) => {
const elem = <Component args={args} />
if (result) result.rerender(elem)
else result = render(elem)
return result
}
}
function testIsRef(ref: SpringRef | null) {
const props = [
'add',
'delete',
'pause',
'resume',
'set',
'start',
'stop',
'update',
'_getProps',
]
props.forEach(prop => expect(ref).toHaveProperty(prop))
}
|
6,380 | 0 | petrpan-code/pmndrs/react-spring/packages/parallax | petrpan-code/pmndrs/react-spring/packages/parallax/test/tsconfig.json | {
"compilerOptions": {
"target": "ESNext",
"lib": ["DOM", "DOM.Iterable", "ESNext"],
"types": ["vite/client"],
"allowJs": true,
"skipLibCheck": false,
"esModuleInterop": false,
"allowSyntheticDefaultImports": true,
"strict": true,
"module": "ESNext",
"moduleResolution": "Node",
"resolveJsonModule": true,
"isolatedModules": true,
"noEmit": true,
"jsx": "react"
},
"include": ["./src"]
}
|
6,391 | 0 | petrpan-code/pmndrs/react-spring/packages/rafz | petrpan-code/pmndrs/react-spring/packages/rafz/src/index.test.ts | import createMockRaf, { MockRaf } from 'mock-raf'
import { raf, __raf } from './index'
import { Globals } from '@react-spring/shared'
let mockRaf: MockRaf
beforeEach(() => {
mockRaf = createMockRaf()
Globals.assign({
now: mockRaf.now,
requestAnimationFrame: mockRaf.raf,
})
raf.use(mockRaf.raf)
__raf.clear()
})
describe('raf looping', () => {
it('is not initially looping', () => {
expect(__raf.isRunning()).toBe(false)
})
it('loops when update is registered', () => {
raf(() => true)
expect(__raf.isRunning()).toBe(true)
mockRaf.step()
expect(__raf.isRunning()).toBe(true)
})
it('stops looping after single job', () => {
// eslint-disable-next-line @typescript-eslint/no-empty-function
raf(() => {})
mockRaf.step()
expect(__raf.isRunning()).toBe(true)
mockRaf.step()
expect(__raf.isRunning()).toBe(false)
})
it('resumes running jobs after stopping looping', () => {
const fn = jest.fn().mockReturnValue(false)
raf(fn)
mockRaf.step()
expect(fn).toHaveBeenCalledTimes(1)
raf(fn)
mockRaf.step()
expect(__raf.isRunning()).toBe(true)
mockRaf.step()
expect(__raf.isRunning()).toBe(false)
expect(fn).toHaveBeenCalledTimes(2)
})
it('loops as long as one update loop is scheduled', () => {
raf(() => true)
raf(() => false)
mockRaf.step()
expect(__raf.isRunning()).toBe(true)
mockRaf.step()
expect(__raf.isRunning()).toBe(true)
})
})
|
6,416 | 0 | petrpan-code/pmndrs/react-spring/packages/shared | petrpan-code/pmndrs/react-spring/packages/shared/src/createInterpolator.test.ts | import { createInterpolator, Globals } from '.'
import { createStringInterpolator } from './stringInterpolation'
import { colors } from './colors'
beforeAll(() => {
Globals.assign({
createStringInterpolator,
colors,
})
})
describe('Interpolation', () => {
it('should work with defaults', () => {
const interpolation = createInterpolator({
range: [0, 1],
output: [0, 1],
})
expect(interpolation(0)).toBe(0)
expect(interpolation(0.5)).toBe(0.5)
expect(interpolation(0.8)).toBe(0.8)
expect(interpolation(1)).toBe(1)
})
it('should work with interpolation function as argument', () => {
const interpolation = createInterpolator<number, string>(
value => `scale(${value})`
)
expect(interpolation(0)).toBe('scale(0)')
expect(interpolation(10.5)).toBe('scale(10.5)')
})
it('should work with range arrays as arguments', () => {
const interpolation = createInterpolator([0, 1], [100, 200])
expect(interpolation(0)).toBe(100)
expect(interpolation(0.5)).toBe(150)
expect(interpolation(0.8)).toBe(180)
expect(interpolation(1)).toBe(200)
})
it('should work with output range', () => {
const interpolation = createInterpolator({
range: [0, 1],
output: [100, 200],
})
expect(interpolation(0)).toBe(100)
expect(interpolation(0.5)).toBe(150)
expect(interpolation(0.8)).toBe(180)
expect(interpolation(1)).toBe(200)
})
it('should work with input range', () => {
const interpolation = createInterpolator({
range: [100, 200],
output: [0, 1],
})
expect(interpolation(100)).toBe(0)
expect(interpolation(150)).toBe(0.5)
expect(interpolation(180)).toBe(0.8)
expect(interpolation(200)).toBe(1)
})
it('should work with keyframes without extrapolate', () => {
const interpolation = createInterpolator({
range: [0, 1, 2],
output: [0.2, 1, 0.2],
extrapolate: 'clamp',
})
expect(interpolation(5)).toBeCloseTo(0.2)
})
it('should work with output ranges as string', () => {
const interpolation = createInterpolator({
range: [0, 1],
output: ['rgba(0, 100, 200, 0)', 'rgba(50, 150, 250, 0.4)'],
})
expect(interpolation(0)).toBe('rgba(0, 100, 200, 0)')
expect(interpolation(0.5)).toBe('rgba(25, 125, 225, 0.2)')
expect(interpolation(1)).toBe('rgba(50, 150, 250, 0.4)')
})
it('should work with output ranges as short hex string', () => {
const interpolation = createInterpolator({
range: [0, 1],
output: ['#024', '#9BF'],
})
expect(interpolation(0)).toBe('rgba(0, 34, 68, 1)')
expect(interpolation(0.5)).toBe('rgba(77, 111, 162, 1)')
expect(interpolation(1)).toBe('rgba(153, 187, 255, 1)')
})
it('should work with output ranges as long hex string', () => {
const interpolation = createInterpolator({
range: [0, 1],
output: ['#FF9500', '#87FC70'],
})
expect(interpolation(0)).toBe('rgba(255, 149, 0, 1)')
expect(interpolation(0.5)).toBe('rgba(195, 201, 56, 1)')
expect(interpolation(1)).toBe('rgba(135, 252, 112, 1)')
})
it('should work with output ranges with mixed hex and rgba strings', () => {
const interpolation = createInterpolator({
range: [0, 1],
output: ['rgba(100, 120, 140, 0.4)', '#87FC70'],
})
expect(interpolation(0)).toBe('rgba(100, 120, 140, 0.4)')
expect(interpolation(0.5)).toBe('rgba(118, 186, 126, 0.7)')
expect(interpolation(1)).toBe('rgba(135, 252, 112, 1)')
})
it('should work with negative and decimal values in string ranges', () => {
const interpolation = createInterpolator({
range: [0, 1],
output: ['-100.5deg', '100deg'],
})
expect(interpolation(0)).toBe('-100.5deg')
expect(interpolation(0.5)).toBe('-0.25deg')
expect(interpolation(1)).toBe('100deg')
})
it('should interpolate between number and unit', () => {
const interpolation = createInterpolator({
range: [0, 1],
output: ['0', '100%'],
})
expect(interpolation(0.5)).toBe('50%')
})
it('should support a mix of color patterns', () => {
const interpolation = createInterpolator({
range: [0, 1, 2],
output: ['rgba(0, 100, 200, 0)', 'rgb(50, 150, 250)', 'red'],
})
expect(interpolation(0)).toBe('rgba(0, 100, 200, 0)')
expect(interpolation(0.5)).toBe('rgba(25, 125, 225, 0.5)')
expect(interpolation(1.5)).toBe('rgba(153, 75, 125, 1)')
expect(interpolation(2)).toBe('rgba(255, 0, 0, 1)')
})
it('should round rgb values', () => {
const interpolation = createInterpolator({
range: [0, 1],
output: ['rgba(0, 0, 0, 0)', 'rgba(3, 3, 3, 1)'],
})
expect(interpolation(0.5)).toBe('rgba(2, 2, 2, 0.5)')
})
it('should not match partial color names', () => {
const interpolation = createInterpolator({
range: [0, 1],
output: ['grayscale(0%)', 'grayscale(100%)'],
})
expect(interpolation(0.5)).toBe('grayscale(50%)')
})
describe('CSS Variables', () => {
const originalGetComputedStyle = window.getComputedStyle
const getComputedStyleMock = () => ({
getPropertyValue: (variableName: '--from' | '--to' | '--no') => {
switch (variableName) {
case '--from':
return '#3cffd0'
case '--to':
return '#277ef4'
case '--no':
return undefined
default:
throw Error('Should never happen')
}
},
})
beforeAll(() => {
// @ts-expect-error for testing purposes only.
window.getComputedStyle = getComputedStyleMock
})
afterAll(() => {
window.getComputedStyle = originalGetComputedStyle
})
it('should correctly parse variables', () => {
const interpolation = createInterpolator({
range: [0, 1],
output: ['var(--to)', 'var(--from)'],
})
expect(interpolation(0.0)).toBe('rgba(39, 126, 244, 1)')
expect(interpolation(0.5)).toBe('rgba(50, 191, 226, 1)')
expect(interpolation(1.0)).toBe('rgba(60, 255, 208, 1)')
})
it('should return the fallbacks if the variable cannot be found', () => {
const interpolation = createInterpolator({
range: [0, 1],
output: ['var(--no, pink)', 'var(--no, purple)'],
})
expect(interpolation(0.0)).toBe('rgba(255, 192, 203, 1)')
expect(interpolation(0.5)).toBe('rgba(192, 96, 166, 1)')
expect(interpolation(1.0)).toBe('rgba(128, 0, 128, 1)')
})
it('should correctly parse the fallback if its a variable', () => {
let interpolation = createInterpolator({
range: [0, 1],
output: ['var(--no, --to)', 'var(--no, --from)'],
})
expect(interpolation(0.0)).toBe('rgba(39, 126, 244, 1)')
expect(interpolation(0.5)).toBe('rgba(50, 191, 226, 1)')
expect(interpolation(1.0)).toBe('rgba(60, 255, 208, 1)')
interpolation = createInterpolator({
range: [0, 1],
output: ['var(--no, var(--to))', 'var(--no, var(--from))'],
})
expect(interpolation(0.0)).toBe('rgba(39, 126, 244, 1)')
expect(interpolation(0.5)).toBe('rgba(50, 191, 226, 1)')
expect(interpolation(1.0)).toBe('rgba(60, 255, 208, 1)')
interpolation = createInterpolator({
range: [0, 1],
output: ['var(--no, var(--no, pink))', 'var(--no, var(--no, purple))'],
})
expect(interpolation(0.0)).toBe('rgba(255, 192, 203, 1)')
expect(interpolation(0.5)).toBe('rgba(192, 96, 166, 1)')
expect(interpolation(1.0)).toBe('rgba(128, 0, 128, 1)')
})
})
})
|
6,444 | 0 | petrpan-code/pmndrs/react-spring/packages/shared/src | petrpan-code/pmndrs/react-spring/packages/shared/src/hooks/useReducedMotion.test.ts | import { act, renderHook } from '@testing-library/react'
import { useReducedMotion } from './useReducedMotion'
describe('useReducedMotion', () => {
let EVENTS: Record<string, MediaQueryHandler> = {}
const removeEventListenerMock = jest.fn()
type MediaQueryHandler = (mediaQuery: typeof mqDefaults) => void
const mqDefaults = {
matches: false,
onchange: null,
addEventListener: (name: string, handle: MediaQueryHandler) => {
EVENTS[name] = handle
},
removeEventListener: removeEventListenerMock,
}
afterEach(() => {
// reset events
EVENTS = {}
jest.clearAllMocks()
})
it('returns true if "Reduce motion" is enabled', async () => {
window.matchMedia = jest.fn().mockImplementation(query => {
return {
...mqDefaults,
matches: true,
media: query,
}
})
const { result } = renderHook(useReducedMotion)
expect(result.current).toBe(true)
})
it('returns false if "Reduce motion" is disabled', async () => {
window.matchMedia = jest.fn().mockImplementation(query => {
return {
...mqDefaults,
media: query,
}
})
const { result } = renderHook(useReducedMotion)
expect(result.current).toBe(false)
})
it('handles change of "prefers-reduce-motion" media query value', async () => {
window.matchMedia = jest.fn().mockImplementation(query => {
return {
...mqDefaults,
media: query,
}
})
const { result } = renderHook(useReducedMotion)
expect(result.current).toBe(false)
act(() => {
EVENTS.change({
...mqDefaults,
matches: true,
})
})
expect(result.current).toBe(true)
})
it('successfully removes listener on unmount', () => {
window.matchMedia = jest.fn().mockImplementation(query => {
return {
...mqDefaults,
media: query,
}
})
const { unmount } = renderHook(useReducedMotion)
unmount()
expect(removeEventListenerMock).toHaveBeenCalled()
})
})
|
6,490 | 0 | petrpan-code/pmndrs/react-spring/targets/web | petrpan-code/pmndrs/react-spring/targets/web/src/animated.test.tsx | import * as React from 'react'
import { forwardRef } from 'react'
import { render } from '@testing-library/react'
import '@testing-library/jest-dom/extend-expect'
import createMockRaf, { MockRaf } from 'mock-raf'
import { Globals } from '@react-spring/shared'
import { SpringValue, Animatable } from '@react-spring/core'
import { a } from './index'
let mockRaf: MockRaf
beforeEach(() => {
mockRaf = createMockRaf()
Globals.assign({
now: mockRaf.now,
requestAnimationFrame: mockRaf.raf,
})
})
describe('animated component', () => {
it('creates an HTML element from a tag name', () => {
const AnimatedH1 = a('h1')
const { queryByTitle } = render(
<AnimatedH1 title="Foo" style={{ color: 'red' }}>
Bar
</AnimatedH1>
)
expect(queryByTitle('Foo')).toBeTruthy()
})
it('wraps a component', () => {
const Name = forwardRef<
HTMLHeadingElement,
{ name: string; other: string; children: React.ReactNode }
>((props, ref) => (
<h2 title={props.name} ref={ref}>
{props.children}
</h2>
))
const AnimatedName = a(Name)
const child = spring('Animated Text')
const name = spring('name')
const { queryByTitle } = render(
<AnimatedName name={name} other="test">
{child}
</AnimatedName>
)
const el: any = queryByTitle('name')!
expect(el).toBeTruthy()
expect(el.textContent).toBe('Animated Text')
})
it('accepts Animated values in style prop', () => {
const opacity = spring(0)
const { queryByText } = render(
<a.div style={{ opacity, color: 'red' }}>Text</a.div>
)
const div: any = queryByText('Text')!
expect(div).toBeTruthy()
expect(div.style.opacity).toBe('0')
opacity.set(1)
mockRaf.step()
expect(div.style.opacity).toBe('1')
})
it('accepts Animated values in custom style prop', () => {
const Name = forwardRef<
HTMLHeadingElement,
{ style: { color: string; opacity?: number }; children: React.ReactNode }
>((props, ref) => (
<h2 ref={ref} style={props.style}>
{props.children}
</h2>
))
const AnimatedName = a(Name)
const opacity = spring(0.5)
const { queryByText } = render(
<AnimatedName
style={{
opacity: opacity,
color: 'red',
}}
>
Text
</AnimatedName>
)
const div: any = queryByText('Text')!
expect(div).toBeTruthy()
expect(div.style.opacity).toBe('0.5')
opacity.set(1)
mockRaf.step()
expect(div.style.opacity).toBe('1')
})
it('accepts scrollTop and scrollLeft properties', () => {
const scrollTop = spring(0)
const { queryByTestId } = render(
<a.div
scrollTop={scrollTop}
scrollLeft={0}
style={{ height: 100 }}
data-testid="wrapper"
>
<div style={{ height: 200 }} />
</a.div>
)
const wrapper: any = queryByTestId('wrapper')!
expect(wrapper.scrollTop).toBe(0)
expect(wrapper.scrollLeft).toBe(0)
scrollTop.set(20)
mockRaf.step()
expect(wrapper.scrollTop).toBe(20)
})
it('accepts x/y/z as style keys equivalent to `translate3d`transform function', () => {
const { queryByTestId, rerender } = render(
<a.div style={{ x: 10 }} data-testid="wrapper" />
)
const wrapper: any = queryByTestId('wrapper')!
expect(wrapper.style.transform).toBe('translate3d(10px,0,0)')
rerender(<a.div style={{ y: '10%' }} data-testid="wrapper" />)
expect(wrapper.style.transform).toBe('translate3d(0,10%,0)')
rerender(<a.div style={{ z: 0.3 }} data-testid="wrapper" />)
expect(wrapper.style.transform).toBe('translate3d(0,0,0.3px)')
rerender(
<a.div style={{ x: 10, y: '10%', z: 0.3 }} data-testid="wrapper" />
)
expect(wrapper.style.transform).toBe('translate3d(10px,10%,0.3px)')
})
it('accepts arrays for transform functions used as style keys', () => {
const { queryByTestId } = render(
<a.div style={{ scale: [1, 2] }} data-testid="wrapper" />
)
const wrapper: any = queryByTestId('wrapper')!
expect(wrapper.style.transform).toBe('scale(1,2)')
})
it('accepts Animated values or Animated arrays as attributes', () => {
const scale = spring(2)
const translate = spring([10, 20] as const)
const translate3d = [spring(30), spring(40), '50px'] as const
const { queryByTestId } = render(
<a.div style={{ scale, translate, translate3d }} data-testid="wrapper" />
)
const wrapper: any = queryByTestId('wrapper')!
expect(wrapper.style.transform).toBe(
'scale(2) translate(10px,20px) translate3d(30px,40px,50px)'
)
})
it('updates all values of Animated arrays', () => {
const translate3d = spring([10, 20, 30] as const)
const { queryByTestId } = render(
<a.div style={{ translate3d }} data-testid="wrapper" />
)
const wrapper: any = queryByTestId('wrapper')!
expect(wrapper.style.transform).toBe('translate3d(10px,20px,30px)')
translate3d.set([11, 21, 31] as const)
mockRaf.step()
expect(wrapper.style.transform).toBe('translate3d(11px,21px,31px)')
})
it('sets default units to unit-less values passed as transform functions', () => {
const { queryByTestId } = render(
<a.div
style={{
x: 10,
scale: [1, 2],
rotate: 30,
skewX: 10,
transform: 'translateX(10px)',
}}
data-testid="wrapper"
/>
)
const wrapper: any = queryByTestId('wrapper')!
expect(wrapper.style.transform).toBe(
'translate3d(10px,0,0) scale(1,2) rotate(30deg) skewX(10deg) translateX(10px)'
)
})
it('only applies default units to the fourth value of `rotate3d`', () => {
const { queryByTestId } = render(
<a.div style={{ rotate3d: [1, 0, 0, 30] }} data-testid="wrapper" />
)
const wrapper: any = queryByTestId('wrapper')!
expect(wrapper.style.transform).toBe('rotate3d(1,0,0,30deg)')
})
it('applies `transform:none` when identity transform is detected', () => {
const z = spring(0)
const { queryByTestId } = render(
<a.div
style={{
x: 0,
y: '0px',
z,
scale: 1,
skewX: 0,
transformOrigin: 'bottom center',
rotate3d: [1, 0, 0, '0deg'],
}}
data-testid="wrapper"
/>
)
const wrapper: any = queryByTestId('wrapper')!
expect(wrapper.style.transform).toBe('none')
})
it('preserves transform-style and transform-origin properties', () => {
const { queryByTestId } = render(
<a.div
style={{
transformOrigin: 'bottom center',
transformStyle: 'preserve-3d',
transform: 'translateX(40px)',
scale: [1, 2],
}}
data-testid="wrapper"
/>
)
const wrapper: any = queryByTestId('wrapper')!
expect(wrapper.style.transformOrigin).toBe('bottom center')
expect(wrapper.style.transformStyle).toBe('preserve-3d')
expect(wrapper.style.transform).toBe('translateX(40px) scale(1,2)')
})
})
function spring<T>(value: T): SpringValue<Animatable<T>> {
return new SpringValue(value!)
}
|
6,589 | 0 | petrpan-code/pmndrs/react-three-fiber/packages/eslint-plugin/tests | petrpan-code/pmndrs/react-three-fiber/packages/eslint-plugin/tests/rules/no-clone-in-loop.test.ts | import { RuleTester } from 'eslint'
import rule from '../../src/rules/no-clone-in-loop'
const tester = new RuleTester({
parserOptions: { ecmaVersion: 2015 },
})
tester.run('no-new-in-loop', rule, {
valid: [
`
const vec = new THREE.Vector3()
useFrame(() => {
ref.current.position.copy(vec)
})
`,
`
useFrame(() => {
clone()
})
`,
`
useFrame(() => {
const clone = vec.copy();
})
`,
],
invalid: [
{
code: `
useFrame(() => {
ref.current.position.clone()
})
`,
errors: [{ messageId: 'noClone' }],
},
],
})
|
6,590 | 0 | petrpan-code/pmndrs/react-three-fiber/packages/eslint-plugin/tests | petrpan-code/pmndrs/react-three-fiber/packages/eslint-plugin/tests/rules/no-new-in-loop.test.ts | import { RuleTester } from 'eslint'
import rule from '../../src/rules/no-new-in-loop'
const tester = new RuleTester({
parserOptions: { ecmaVersion: 2015 },
})
tester.run('no-new-in-loop', rule, {
valid: [
`
const vec = new THREE.Vector3()
useFrame(() => {
ref.current.position.copy(vec)
})
`,
`
const vec = new THREE.Vector3()
useFrame(() => {
ref.current.position.lerp(vec.set(x, y, z), 0.1)
})
`,
`
const vec = new Vector3()
useFrame(() => {
ref.current.position.copy(vec)
})
`,
`
const vec = new Vector3()
useFrame(() => {
ref.current.position.lerp(vec.set(x, y, z), 0.1)
})
`,
],
invalid: [
{
code: `
useFrame(() => {
ref.current.position.lerp(new THREE.Vector3(x, y, z), 0.1)
})
`,
errors: [{ messageId: 'noNew' }],
},
{
code: `
useFrame(() => {
ref.current.position.lerp(new Vector3(x, y, z), 0.1)
})
`,
errors: [{ messageId: 'noNew' }],
},
],
})
|
6,617 | 0 | petrpan-code/pmndrs/react-three-fiber/packages/fiber/tests | petrpan-code/pmndrs/react-three-fiber/packages/fiber/tests/core/events.test.tsx | import * as React from 'react'
import { render, fireEvent, RenderResult } from '@testing-library/react'
import { Canvas, act } from '../../src'
const getContainer = () => document.querySelector('canvas')?.parentNode?.parentNode as HTMLDivElement
describe('events', () => {
it('can handle onPointerDown', async () => {
const handlePointerDown = jest.fn()
await act(async () => {
render(
<Canvas>
<mesh onPointerDown={handlePointerDown}>
<boxGeometry args={[2, 2]} />
<meshBasicMaterial />
</mesh>
</Canvas>,
)
})
const evt = new PointerEvent('pointerdown')
Object.defineProperty(evt, 'offsetX', { get: () => 577 })
Object.defineProperty(evt, 'offsetY', { get: () => 480 })
fireEvent(getContainer(), evt)
expect(handlePointerDown).toHaveBeenCalled()
})
it('can handle onPointerMissed', async () => {
const handleClick = jest.fn()
const handleMissed = jest.fn()
await act(async () => {
render(
<Canvas>
<mesh onPointerMissed={handleMissed} onClick={handleClick}>
<boxGeometry args={[2, 2]} />
<meshBasicMaterial />
</mesh>
</Canvas>,
)
})
const evt = new MouseEvent('click')
Object.defineProperty(evt, 'offsetX', { get: () => 0 })
Object.defineProperty(evt, 'offsetY', { get: () => 0 })
fireEvent(getContainer(), evt)
expect(handleClick).not.toHaveBeenCalled()
expect(handleMissed).toHaveBeenCalledWith(evt)
})
it('should not fire onPointerMissed when same element is clicked', async () => {
const handleClick = jest.fn()
const handleMissed = jest.fn()
await act(async () => {
render(
<Canvas>
<mesh onPointerMissed={handleMissed} onClick={handleClick}>
<boxGeometry args={[2, 2]} />
<meshBasicMaterial />
</mesh>
</Canvas>,
)
})
const down = new PointerEvent('pointerdown')
Object.defineProperty(down, 'offsetX', { get: () => 577 })
Object.defineProperty(down, 'offsetY', { get: () => 480 })
fireEvent(getContainer(), down)
const up = new PointerEvent('pointerup')
Object.defineProperty(up, 'offsetX', { get: () => 577 })
Object.defineProperty(up, 'offsetY', { get: () => 480 })
const evt = new MouseEvent('click')
Object.defineProperty(evt, 'offsetX', { get: () => 577 })
Object.defineProperty(evt, 'offsetY', { get: () => 480 })
fireEvent(getContainer(), evt)
expect(handleClick).toHaveBeenCalled()
expect(handleMissed).not.toHaveBeenCalled()
})
it('should not fire onPointerMissed on parent when child element is clicked', async () => {
const handleClick = jest.fn()
const handleMissed = jest.fn()
await act(async () => {
render(
<Canvas>
<group onPointerMissed={handleMissed}>
<mesh onClick={handleClick}>
<boxGeometry args={[2, 2]} />
<meshBasicMaterial />
</mesh>
</group>
</Canvas>,
)
})
const down = new PointerEvent('pointerdown')
Object.defineProperty(down, 'offsetX', { get: () => 577 })
Object.defineProperty(down, 'offsetY', { get: () => 480 })
fireEvent(getContainer(), down)
const up = new PointerEvent('pointerup')
Object.defineProperty(up, 'offsetX', { get: () => 577 })
Object.defineProperty(up, 'offsetY', { get: () => 480 })
const evt = new MouseEvent('click')
Object.defineProperty(evt, 'offsetX', { get: () => 577 })
Object.defineProperty(evt, 'offsetY', { get: () => 480 })
fireEvent(getContainer(), evt)
expect(handleClick).toHaveBeenCalled()
expect(handleMissed).not.toHaveBeenCalled()
})
it('can handle onPointerMissed on Canvas', async () => {
const handleMissed = jest.fn()
await act(async () => {
render(
<Canvas onPointerMissed={handleMissed}>
<mesh>
<boxGeometry args={[2, 2]} />
<meshBasicMaterial />
</mesh>
</Canvas>,
)
})
const evt = new MouseEvent('click')
Object.defineProperty(evt, 'offsetX', { get: () => 0 })
Object.defineProperty(evt, 'offsetY', { get: () => 0 })
fireEvent(getContainer(), evt)
expect(handleMissed).toHaveBeenCalledWith(evt)
})
it('can handle onPointerMove', async () => {
const handlePointerMove = jest.fn()
const handlePointerOver = jest.fn()
const handlePointerEnter = jest.fn()
const handlePointerOut = jest.fn()
await act(async () => {
render(
<Canvas>
<mesh
onPointerOut={handlePointerOut}
onPointerEnter={handlePointerEnter}
onPointerMove={handlePointerMove}
onPointerOver={handlePointerOver}>
<boxGeometry args={[2, 2]} />
<meshBasicMaterial />
</mesh>
</Canvas>,
)
})
const evt1 = new PointerEvent('pointermove')
Object.defineProperty(evt1, 'offsetX', { get: () => 577 })
Object.defineProperty(evt1, 'offsetY', { get: () => 480 })
fireEvent(getContainer(), evt1)
expect(handlePointerMove).toHaveBeenCalled()
expect(handlePointerOver).toHaveBeenCalled()
expect(handlePointerEnter).toHaveBeenCalled()
const evt2 = new PointerEvent('pointermove')
Object.defineProperty(evt2, 'offsetX', { get: () => 0 })
Object.defineProperty(evt2, 'offsetY', { get: () => 0 })
fireEvent(getContainer(), evt2)
expect(handlePointerOut).toHaveBeenCalled()
})
it('should handle stopPropogation', async () => {
const handlePointerEnter = jest.fn().mockImplementation((e) => {
expect(() => e.stopPropagation()).not.toThrow()
})
const handlePointerLeave = jest.fn()
await act(async () => {
render(
<Canvas>
<mesh onPointerLeave={handlePointerLeave} onPointerEnter={handlePointerEnter}>
<boxGeometry args={[2, 2]} />
<meshBasicMaterial />
</mesh>
<mesh position-z={3}>
<boxGeometry args={[2, 2]} />
<meshBasicMaterial />
</mesh>
</Canvas>,
)
})
const evt1 = new PointerEvent('pointermove')
Object.defineProperty(evt1, 'offsetX', { get: () => 577 })
Object.defineProperty(evt1, 'offsetY', { get: () => 480 })
fireEvent(getContainer(), evt1)
expect(handlePointerEnter).toHaveBeenCalled()
const evt2 = new PointerEvent('pointermove')
Object.defineProperty(evt2, 'offsetX', { get: () => 0 })
Object.defineProperty(evt2, 'offsetY', { get: () => 0 })
fireEvent(getContainer(), evt2)
expect(handlePointerLeave).toHaveBeenCalled()
})
it('should handle stopPropagation on click events', async () => {
const handleClickFront = jest.fn((e) => e.stopPropagation())
const handleClickRear = jest.fn()
await act(async () => {
render(
<Canvas>
<mesh onClick={handleClickFront}>
<boxGeometry args={[2, 2]} />
<meshBasicMaterial />
</mesh>
<mesh onClick={handleClickRear} position-z={-3}>
<boxGeometry args={[2, 2]} />
<meshBasicMaterial />
</mesh>
</Canvas>,
)
})
const down = new PointerEvent('pointerdown')
Object.defineProperty(down, 'offsetX', { get: () => 577 })
Object.defineProperty(down, 'offsetY', { get: () => 480 })
fireEvent(getContainer(), down)
const up = new PointerEvent('pointerup')
Object.defineProperty(up, 'offsetX', { get: () => 577 })
Object.defineProperty(up, 'offsetY', { get: () => 480 })
fireEvent(getContainer(), up)
const event = new MouseEvent('click')
Object.defineProperty(event, 'offsetX', { get: () => 577 })
Object.defineProperty(event, 'offsetY', { get: () => 480 })
fireEvent(getContainer(), event)
expect(handleClickFront).toHaveBeenCalled()
expect(handleClickRear).not.toHaveBeenCalled()
})
describe('web pointer capture', () => {
const handlePointerMove = jest.fn()
const handlePointerDown = jest.fn((ev) => (ev.target as any).setPointerCapture(ev.pointerId))
const handlePointerUp = jest.fn((ev) => (ev.target as any).releasePointerCapture(ev.pointerId))
const handlePointerEnter = jest.fn()
const handlePointerLeave = jest.fn()
/* This component lets us unmount the event-handling object */
function PointerCaptureTest(props: { hasMesh: boolean, manualRelease?: boolean }) {
return (
<Canvas>
{props.hasMesh && (
<mesh onPointerDown={handlePointerDown} onPointerMove={handlePointerMove} onPointerUp={props.manualRelease ? handlePointerUp : undefined} onPointerLeave={handlePointerLeave} onPointerEnter={handlePointerEnter}>
<boxGeometry args={[2, 2]} />
<meshBasicMaterial />
</mesh>
)}
</Canvas>
)
}
const pointerId = 1234
it('should release when the capture target is unmounted', async () => {
let renderResult: RenderResult = undefined!
await act(async () => {
renderResult = render(<PointerCaptureTest hasMesh={true} />)
return renderResult
})
const canvas = getContainer()
canvas.setPointerCapture = jest.fn()
canvas.releasePointerCapture = jest.fn()
const down = new PointerEvent('pointerdown', { pointerId })
Object.defineProperty(down, 'offsetX', { get: () => 577 })
Object.defineProperty(down, 'offsetY', { get: () => 480 })
/* testing-utils/react's fireEvent wraps the event like React does, so it doesn't match how our event handlers are called in production, so we call dispatchEvent directly. */
await act(async () => canvas.dispatchEvent(down))
/* This should have captured the DOM pointer */
expect(handlePointerDown).toHaveBeenCalledTimes(1)
expect(canvas.setPointerCapture).toHaveBeenCalledWith(pointerId)
expect(canvas.releasePointerCapture).not.toHaveBeenCalled()
/* Now remove the mesh */
await act(async () => renderResult.rerender(<PointerCaptureTest hasMesh={false} />))
expect(canvas.releasePointerCapture).toHaveBeenCalledWith(pointerId)
const move = new PointerEvent('pointerdown', { pointerId })
Object.defineProperty(move, 'offsetX', { get: () => 577 })
Object.defineProperty(move, 'offsetY', { get: () => 480 })
await act(async () => canvas.dispatchEvent(move))
/* There should now be no pointer capture */
expect(handlePointerMove).not.toHaveBeenCalled()
})
it('should not leave when captured', async () => {
let renderResult: RenderResult = undefined!
await act(async () => {
renderResult = render(<PointerCaptureTest hasMesh manualRelease />)
return renderResult
})
const canvas = getContainer()
canvas.setPointerCapture = jest.fn()
canvas.releasePointerCapture = jest.fn()
const moveIn = new PointerEvent('pointermove', { pointerId })
Object.defineProperty(moveIn, 'offsetX', { get: () => 577 })
Object.defineProperty(moveIn, 'offsetY', { get: () => 480 })
const moveOut = new PointerEvent('pointermove', { pointerId })
Object.defineProperty(moveOut, 'offsetX', { get: () => -10000 })
Object.defineProperty(moveOut, 'offsetY', { get: () => -10000 })
/* testing-utils/react's fireEvent wraps the event like React does, so it doesn't match how our event handlers are called in production, so we call dispatchEvent directly. */
await act(async () => canvas.dispatchEvent(moveIn))
expect(handlePointerEnter).toHaveBeenCalledTimes(1);
expect(handlePointerMove).toHaveBeenCalledTimes(1);
const down = new PointerEvent('pointerdown', { pointerId })
Object.defineProperty(down, 'offsetX', { get: () => 577 })
Object.defineProperty(down, 'offsetY', { get: () => 480 })
await act(async () => canvas.dispatchEvent(down))
// If we move the pointer now, when it is captured, it should raise the onPointerMove event even though the pointer is not over the element,
// and NOT raise the onPointerLeave event.
await act(async () => canvas.dispatchEvent(moveOut))
expect(handlePointerMove).toHaveBeenCalledTimes(2);
expect(handlePointerLeave).not.toHaveBeenCalled();
await act(async () => canvas.dispatchEvent(moveIn))
expect(handlePointerMove).toHaveBeenCalledTimes(3);
const up = new PointerEvent('pointerup', { pointerId })
Object.defineProperty(up, 'offsetX', { get: () => 577 })
Object.defineProperty(up, 'offsetY', { get: () => 480 })
const lostpointercapture = new PointerEvent('lostpointercapture', { pointerId })
await act(async () => canvas.dispatchEvent(up))
await act(async () => canvas.dispatchEvent(lostpointercapture))
// The pointer is still over the element, so onPointerLeave should not have been called.
expect(handlePointerLeave).not.toHaveBeenCalled();
// The element pointer should no longer be captured, so moving it away should call onPointerLeave.
await act(async () => canvas.dispatchEvent(moveOut));
expect(handlePointerEnter).toHaveBeenCalledTimes(1);
expect(handlePointerLeave).toHaveBeenCalledTimes(1)
})
})
})
|
6,618 | 0 | petrpan-code/pmndrs/react-three-fiber/packages/fiber/tests | petrpan-code/pmndrs/react-three-fiber/packages/fiber/tests/core/hooks.test.tsx | import * as React from 'react'
import * as THREE from 'three'
import * as Stdlib from 'three-stdlib'
import { createCanvas } from '@react-three/test-renderer/src/createTestCanvas'
import { waitFor } from '@react-three/test-renderer'
import {
createRoot,
advance,
useLoader,
act,
useThree,
useGraph,
useFrame,
ObjectMap,
useInstanceHandle,
LocalState,
} from '../../src'
import { Instance } from 'packages/fiber/src/core/renderer'
describe('hooks', () => {
let canvas: HTMLCanvasElement = null!
beforeEach(() => {
canvas = createCanvas()
})
it('can handle useThree hook', async () => {
let result = {} as {
camera: THREE.Camera
scene: THREE.Scene
raycaster: THREE.Raycaster
size: { width: number; height: number }
}
const Component = () => {
/**
* this causes an act problem, it'd be
* good to figure out the best way to
* resolve this at some point
*/
const res = useThree((state) => ({
camera: state.camera,
scene: state.scene,
size: state.size,
raycaster: state.raycaster,
}))
result = res
return <group />
}
await act(async () => {
createRoot(canvas).render(<Component />)
})
expect(result.camera instanceof THREE.Camera).toBeTruthy()
expect(result.scene instanceof THREE.Scene).toBeTruthy()
expect(result.raycaster instanceof THREE.Raycaster).toBeTruthy()
expect(result.size).toEqual({ height: 0, width: 0, top: 0, left: 0, updateStyle: false })
})
it('can handle useFrame hook', async () => {
const frameCalls: number[] = []
const Component = () => {
const ref = React.useRef<THREE.Mesh>(null!)
useFrame((_, delta) => {
frameCalls.push(delta)
ref.current.position.x = 1
})
return (
<mesh ref={ref}>
<boxGeometry args={[2, 2]} />
<meshBasicMaterial />
</mesh>
)
}
let scene: THREE.Scene = null!
await act(
async () =>
(scene = createRoot(canvas)
.configure({ frameloop: 'never' })
.render(<Component />)
.getState().scene),
)
advance(Date.now())
expect(scene.children[0].position.x).toEqual(1)
expect(frameCalls.length).toBeGreaterThan(0)
})
it('can handle useLoader hook', async () => {
const MockMesh = new THREE.Mesh()
jest.spyOn(Stdlib, 'GLTFLoader').mockImplementation(
() =>
({
load: jest.fn().mockImplementation((_url, onLoad) => {
onLoad(MockMesh)
}),
} as unknown as Stdlib.GLTFLoader),
)
const Component = () => {
const model = useLoader(Stdlib.GLTFLoader, '/suzanne.glb')
return <primitive object={model} />
}
let scene: THREE.Scene = null!
await act(async () => {
scene = createRoot(canvas)
.render(
<React.Suspense fallback={null}>
<Component />
</React.Suspense>,
)
.getState().scene
})
await waitFor(() => expect(scene.children[0]).toBeDefined())
expect(scene.children[0]).toBe(MockMesh)
})
it('can handle useLoader hook with an array of strings', async () => {
const MockMesh = new THREE.Mesh()
const MockGroup = new THREE.Group()
const mat1 = new THREE.MeshBasicMaterial()
mat1.name = 'Mat 1'
const mesh1 = new THREE.Mesh(new THREE.BoxGeometry(2, 2), mat1)
mesh1.name = 'Mesh 1'
const mat2 = new THREE.MeshBasicMaterial()
mat2.name = 'Mat 2'
const mesh2 = new THREE.Mesh(new THREE.BoxGeometry(2, 2), mat2)
mesh2.name = 'Mesh 2'
MockGroup.add(mesh1, mesh2)
class TestLoader extends THREE.Loader {
load = jest
.fn()
.mockImplementationOnce((_url, onLoad) => {
onLoad(MockMesh)
})
.mockImplementationOnce((_url, onLoad) => {
onLoad(MockGroup)
})
}
const extensions = jest.fn()
const Component = () => {
const [mockMesh, mockScene] = useLoader(TestLoader, ['/suzanne.glb', '/myModels.glb'], extensions)
return (
<>
<primitive object={mockMesh} />
<primitive object={mockScene} />
</>
)
}
let scene: THREE.Scene = null!
await act(async () => {
scene = createRoot(canvas)
.render(
<React.Suspense fallback={null}>
<Component />
</React.Suspense>,
)
.getState().scene
})
await waitFor(() => expect(scene.children[0]).toBeDefined())
expect(scene.children[0]).toBe(MockMesh)
expect(scene.children[1]).toBe(MockGroup)
expect(extensions).toBeCalledTimes(1)
})
it('can handle useLoader with a loader extension', async () => {
class Loader extends THREE.Loader {
load = (_url: string) => null
}
let proto!: Loader
function Test() {
return useLoader(Loader, '', (loader) => (proto = loader))
}
await act(async () => createRoot(canvas).render(<Test />))
expect(proto).toBeInstanceOf(Loader)
})
it('can handle useGraph hook', async () => {
const group = new THREE.Group()
const mat1 = new THREE.MeshBasicMaterial()
mat1.name = 'Mat 1'
const mesh1 = new THREE.Mesh(new THREE.BoxGeometry(2, 2), mat1)
mesh1.name = 'Mesh 1'
const mat2 = new THREE.MeshBasicMaterial()
mat2.name = 'Mat 2'
const mesh2 = new THREE.Mesh(new THREE.BoxGeometry(2, 2), mat2)
mesh2.name = 'Mesh 2'
const subGroup = new THREE.Group()
const mat3 = new THREE.MeshBasicMaterial()
mat3.name = 'Mat 3'
const mesh3 = new THREE.Mesh(new THREE.BoxGeometry(2, 2), mat3)
mesh3.name = 'Mesh 3'
const mat4 = new THREE.MeshBasicMaterial()
mat4.name = 'Mat 4'
const mesh4 = new THREE.Mesh(new THREE.BoxGeometry(2, 2), mat4)
mesh4.name = 'Mesh 4'
subGroup.add(mesh3, mesh4)
group.add(mesh1, mesh2, subGroup)
let result = {} as ObjectMap
const Component = () => {
const data = useGraph(group)
result = data
return <mesh />
}
await act(async () => {
createRoot(canvas).render(<Component />)
})
expect(result).toEqual({
nodes: {
[mesh1.name]: mesh1,
[mesh2.name]: mesh2,
[mesh3.name]: mesh3,
[mesh4.name]: mesh4,
},
materials: {
[mat1.name]: mat1,
[mat2.name]: mat2,
[mat3.name]: mat3,
[mat4.name]: mat4,
},
})
})
it('can handle useInstanceHandle hook', async () => {
const ref = React.createRef<THREE.Group>()
let instance!: React.MutableRefObject<LocalState>
const Component = () => {
instance = useInstanceHandle(ref)
return <group ref={ref} />
}
await act(async () => createRoot(canvas).render(<Component />))
expect(instance.current).toBe((ref.current as unknown as Instance).__r3f)
})
})
|
6,619 | 0 | petrpan-code/pmndrs/react-three-fiber/packages/fiber/tests | petrpan-code/pmndrs/react-three-fiber/packages/fiber/tests/core/renderer.test.tsx | import * as React from 'react'
import * as THREE from 'three'
import { createCanvas } from '@react-three/test-renderer/src/createTestCanvas'
import {
ReconcilerRoot,
createRoot,
act,
useFrame,
extend,
ReactThreeFiber,
useThree,
createPortal,
} from '../../src/index'
import { UseBoundStore } from 'zustand'
import { privateKeys, RootState } from '../../src/core/store'
import { Instance } from '../../src/core/renderer'
type ComponentMesh = THREE.Mesh<THREE.BoxBufferGeometry, THREE.MeshBasicMaterial>
interface ObjectWithBackground extends THREE.Object3D {
background: THREE.Color
}
/* This class is used for one of the tests */
class HasObject3dMember extends THREE.Object3D {
public attachment?: THREE.Object3D = undefined
}
/* This class is used for one of the tests */
class HasObject3dMethods extends THREE.Object3D {
attachedObj3d?: THREE.Object3D
detachedObj3d?: THREE.Object3D
customAttach(obj3d: THREE.Object3D) {
this.attachedObj3d = obj3d
}
detach(obj3d: THREE.Object3D) {
this.detachedObj3d = obj3d
}
}
class MyColor extends THREE.Color {
constructor(col: number) {
super(col)
}
}
extend({ HasObject3dMember, HasObject3dMethods })
declare module '@react-three/fiber' {
interface ThreeElements {
hasObject3dMember: ReactThreeFiber.Node<HasObject3dMember, typeof HasObject3dMember>
hasObject3dMethods: ReactThreeFiber.Node<HasObject3dMethods, typeof HasObject3dMethods>
myColor: ReactThreeFiber.Node<MyColor, typeof MyColor>
}
}
beforeAll(() => {
Object.defineProperty(window, 'devicePixelRatio', {
configurable: true,
value: 2,
})
})
describe('renderer', () => {
let root: ReconcilerRoot<HTMLCanvasElement> = null!
beforeEach(() => {
const canvas = createCanvas()
root = createRoot(canvas)
})
afterEach(() => {
root.unmount()
})
it('renders a simple component', async () => {
const Mesh = () => {
return (
<mesh>
<boxGeometry args={[2, 2]} />
<meshBasicMaterial />
</mesh>
)
}
let scene: THREE.Scene = null!
await act(async () => {
scene = root.render(<Mesh />).getState().scene
})
expect(scene.children[0].type).toEqual('Mesh')
expect((scene.children[0] as ComponentMesh).geometry.type).toEqual('BoxGeometry')
expect((scene.children[0] as ComponentMesh).material.type).toEqual('MeshBasicMaterial')
expect((scene.children[0] as THREE.Mesh<THREE.BoxGeometry, THREE.MeshStandardMaterial>).material.type).toEqual(
'MeshBasicMaterial',
)
})
it('renders an empty scene', async () => {
const Empty = () => null
let scene: THREE.Scene = null!
await act(async () => {
scene = root.render(<Empty />).getState().scene
})
expect(scene.type).toEqual('Scene')
expect(scene.children).toEqual([])
})
it('can render a composite component', async () => {
class Parent extends React.Component {
render() {
return (
<group>
<color attach="background" args={[0, 0, 0]} />
<Child />
</group>
)
}
}
const Child = () => {
return (
<mesh>
<boxGeometry args={[2, 2]} />
<meshBasicMaterial />
</mesh>
)
}
let scene: THREE.Scene = null!
await act(async () => {
scene = root.render(<Parent />).getState().scene
})
expect(scene.children[0].type).toEqual('Group')
expect((scene.children[0] as ObjectWithBackground).background.getStyle()).toEqual('rgb(0,0,0)')
expect(scene.children[0].children[0].type).toEqual('Mesh')
expect((scene.children[0].children[0] as ComponentMesh).geometry.type).toEqual('BoxGeometry')
expect((scene.children[0].children[0] as ComponentMesh).material.type).toEqual('MeshBasicMaterial')
expect(
(scene.children[0].children[0] as THREE.Mesh<THREE.BoxGeometry, THREE.MeshStandardMaterial>).material.type,
).toEqual('MeshBasicMaterial')
})
it('renders some basics with an update', async () => {
let renders = 0
class Component extends React.PureComponent {
state = { pos: 3 }
componentDidMount() {
this.setState({ pos: 7 })
}
render() {
renders++
return (
<group position-x={this.state.pos}>
<Child />
<Null />
</group>
)
}
}
const Child = () => {
renders++
return <color attach="background" args={[0, 0, 0]} />
}
const Null = () => {
renders++
return null
}
let scene: THREE.Scene = null!
await act(async () => {
scene = root.render(<Component />).getState().scene
})
expect(scene.children[0].position.x).toEqual(7)
expect(renders).toBe(6)
})
it('updates types & names', async () => {
let scene: THREE.Scene = null!
await act(async () => {
scene = root
.render(
<mesh>
<meshBasicMaterial name="basicMat">
<color attach="color" args={[0, 0, 0]} />
</meshBasicMaterial>
</mesh>,
)
.getState().scene
})
expect((scene.children[0] as THREE.Mesh<THREE.BoxGeometry, THREE.MeshBasicMaterial>).material.type).toEqual(
'MeshBasicMaterial',
)
expect((scene.children[0] as THREE.Mesh<THREE.BoxGeometry, THREE.MeshBasicMaterial>).material.name).toEqual(
'basicMat',
)
await act(async () => {
scene = root
.render(
<mesh>
<meshStandardMaterial name="standardMat">
<color attach="color" args={[255, 255, 255]} />
</meshStandardMaterial>
</mesh>,
)
.getState().scene
})
expect((scene.children[0] as THREE.Mesh<THREE.BoxGeometry, THREE.MeshStandardMaterial>).material.type).toEqual(
'MeshStandardMaterial',
)
expect((scene.children[0] as THREE.Mesh<THREE.BoxGeometry, THREE.MeshStandardMaterial>).material.name).toEqual(
'standardMat',
)
})
it('should forward ref three object', async () => {
// Note: Passing directly should be less strict, and assigning current should be more strict
let immutableRef!: React.RefObject<THREE.Mesh>
let mutableRef!: React.MutableRefObject<THREE.Mesh | null>
let mutableRefSpecific!: React.MutableRefObject<THREE.Mesh | null>
const RefTest = () => {
immutableRef = React.createRef()
mutableRef = React.useRef(null)
mutableRefSpecific = React.useRef(null)
return (
<>
<mesh ref={immutableRef} />
<mesh ref={mutableRef} />
<mesh ref={(r) => (mutableRefSpecific.current = r)} />
</>
)
}
await act(async () => {
root.render(<RefTest />)
})
expect(immutableRef.current).toBeTruthy()
expect(mutableRef.current).toBeTruthy()
expect(mutableRefSpecific.current).toBeTruthy()
})
it('attaches Object3D children that use attach', async () => {
let scene: THREE.Scene = null!
await act(async () => {
scene = root
.render(
<hasObject3dMember>
<mesh attach="attachment" />
</hasObject3dMember>,
)
.getState().scene
})
const attachedMesh = (scene.children[0] as HasObject3dMember).attachment
expect(attachedMesh).toBeDefined()
expect(attachedMesh?.type).toBe('Mesh')
// attaching is *instead of* being a regular child
expect(scene.children[0].children.length).toBe(0)
})
it('can attach a Scene', async () => {
let scene: THREE.Scene = null!
await act(async () => {
scene = root
.render(
<hasObject3dMember>
<scene attach="attachment" />
</hasObject3dMember>,
)
.getState().scene
})
const attachedScene = (scene.children[0] as HasObject3dMember).attachment
expect(attachedScene).toBeDefined()
expect(attachedScene?.type).toBe('Scene')
// attaching is *instead of* being a regular child
expect(scene.children[0].children.length).toBe(0)
})
describe('attaches Object3D children that use attachFns', () => {
it('attachFns with cleanup', async () => {
let scene: THREE.Scene = null!
await act(async () => {
scene = root
.render(
<hasObject3dMethods>
<mesh attach={(parent, self) => (parent.customAttach(self), () => parent.detach(self))} />
</hasObject3dMethods>,
)
.getState().scene
})
const attachedMesh = (scene.children[0] as HasObject3dMethods).attachedObj3d
expect(attachedMesh).toBeDefined()
expect(attachedMesh?.type).toBe('Mesh')
// attaching is *instead of* being a regular child
expect(scene.children[0].children.length).toBe(0)
// and now detach ..
expect((scene.children[0] as HasObject3dMethods).detachedObj3d).toBeUndefined()
await act(async () => {
root.render(<hasObject3dMethods />)
})
const detachedMesh = (scene.children[0] as HasObject3dMethods).detachedObj3d
expect(detachedMesh).toBe(attachedMesh)
})
it('attachFns as functions', async () => {
let scene: THREE.Scene = null!
let attachedMesh: Instance = null!
let detachedMesh: Instance = null!
await act(async () => {
scene = root
.render(
<hasObject3dMethods>
<mesh attach={(parent) => ((attachedMesh = parent), () => (detachedMesh = parent))} />
</hasObject3dMethods>,
)
.getState().scene
})
expect(attachedMesh).toBeDefined()
expect(attachedMesh?.type).toBe('Object3D')
// attaching is *instead of* being a regular child
expect(scene.children[0].children.length).toBe(0)
await act(async () => {
root.render(<hasObject3dMethods />)
})
expect(detachedMesh).toBe(attachedMesh)
})
})
it('does the full lifecycle', async () => {
const log: string[] = []
class Log extends React.Component<{ name: string }> {
render() {
log.push('render ' + this.props.name)
return <group />
}
componentDidMount() {
log.push('mount ' + this.props.name)
}
componentWillUnmount() {
log.push('unmount ' + this.props.name)
}
}
await act(async () => {
root.render(<Log key="foo" name="Foo" />)
})
await act(async () => {
root.unmount()
})
expect(log).toEqual(['render Foo', 'mount Foo', 'unmount Foo'])
})
it('will mount/unmount event handlers correctly', async () => {
let state: RootState = null!
let mounted = false
let attachEvents = false
const EventfulComponent = () => (mounted ? <group onClick={attachEvents ? () => void 0 : undefined} /> : null)
// Test initial mount without events
mounted = true
await act(async () => {
state = root.render(<EventfulComponent />).getState()
})
expect(state.internal.interaction.length).toBe(0)
// Test initial mount with events
attachEvents = true
await act(async () => {
state = root.render(<EventfulComponent />).getState()
})
expect(state.internal.interaction.length).not.toBe(0)
// Test events update
attachEvents = false
await act(async () => {
state = root.render(<EventfulComponent />).getState()
})
expect(state.internal.interaction.length).toBe(0)
attachEvents = true
await act(async () => {
state = root.render(<EventfulComponent />).getState()
})
expect(state.internal.interaction.length).not.toBe(0)
// Test unmount with events
mounted = false
await act(async () => {
state = root.render(<EventfulComponent />).getState()
})
expect(state.internal.interaction.length).toBe(0)
})
it('will create an identical instance when reconstructing', async () => {
let state: RootState = null!
const instances: { uuid: string; parentUUID?: string; childUUID?: string }[] = []
const object1 = new THREE.Group()
const object2 = new THREE.Group()
const Test = ({ first }: { first?: boolean }) => (
<primitive object={first ? object1 : object2} onPointerOver={() => null}>
<group />
</primitive>
)
await act(async () => {
state = root.render(<Test first />).getState()
})
instances.push({
uuid: state.scene.children[0].uuid,
parentUUID: state.scene.children[0].parent?.uuid,
childUUID: state.scene.children[0].children[0]?.uuid,
})
expect(state.scene.children[0]).toBe(object1)
await act(async () => {
state = root.render(<Test />).getState()
})
instances.push({
uuid: state.scene.children[0].uuid,
parentUUID: state.scene.children[0].parent?.uuid,
childUUID: state.scene.children[0].children[0]?.uuid,
})
const [oldInstance, newInstance] = instances
// Swapped to new instance
expect(state.scene.children[0]).toBe(object2)
// Preserves scene hierarchy
expect(oldInstance.parentUUID).toBe(newInstance.parentUUID)
expect(oldInstance.childUUID).toBe(newInstance.childUUID)
// Rebinds events
expect(state.internal.interaction.length).not.toBe(0)
})
it('can swap primitives', async () => {
let state: RootState = null!
const o1 = new THREE.Group()
o1.add(new THREE.Group())
const o2 = new THREE.Group()
const Test = ({ n }: { n: number }) => (
<primitive object={n === 1 ? o1 : o2}>
<group attach="test" />
</primitive>
)
await act(async () => {
state = root.render(<Test n={1} />).getState()
})
// Initial object is added with children and attachments
expect(state.scene.children[0]).toBe(o1)
expect(state.scene.children[0].children.length).toBe(1)
expect((state.scene.children[0] as any).test).toBeInstanceOf(THREE.Group)
await act(async () => {
state = root.render(<Test n={2} />).getState()
})
// Swapped to object 2, does not copy old children, copies attachments
expect(state.scene.children[0]).toBe(o2)
expect(state.scene.children[0].children.length).toBe(0)
expect((state.scene.children[0] as any).test).toBeInstanceOf(THREE.Group)
})
it('can swap 4 array primitives', async () => {
let state: RootState = null!
const a = new THREE.Group()
const b = new THREE.Group()
const c = new THREE.Group()
const d = new THREE.Group()
const array = [a, b, c, d]
const Test = ({ array }: { array: THREE.Group[] }) => (
<>
{array.map((group, i) => (
<primitive key={i} object={group} />
))}
</>
)
await act(async () => {
state = root.render(<Test array={array} />).getState()
})
expect(state.scene.children[0]).toBe(a)
expect(state.scene.children[1]).toBe(b)
expect(state.scene.children[2]).toBe(c)
expect(state.scene.children[3]).toBe(d)
const reversedArray = [...array.reverse()]
await act(async () => {
state = root.render(<Test array={reversedArray} />).getState()
})
expect(state.scene.children[0]).toBe(d)
expect(state.scene.children[1]).toBe(c)
expect(state.scene.children[2]).toBe(b)
expect(state.scene.children[3]).toBe(a)
const mixedArray = [b, a, d, c]
await act(async () => {
state = root.render(<Test array={mixedArray} />).getState()
})
expect(state.scene.children[0]).toBe(b)
expect(state.scene.children[1]).toBe(a)
expect(state.scene.children[2]).toBe(d)
expect(state.scene.children[3]).toBe(c)
})
it('will make an Orthographic Camera & set the position', async () => {
let camera: THREE.Camera = null!
await act(async () => {
camera = root
.configure({ orthographic: true, camera: { position: [0, 0, 5] } })
.render(<group />)
.getState().camera
})
expect(camera.type).toEqual('OrthographicCamera')
expect(camera.position.z).toEqual(5)
})
it('should handle an performance changing functions', async () => {
let state: UseBoundStore<RootState> = null!
await act(async () => {
state = root.configure({ dpr: [1, 2], performance: { min: 0.2 } }).render(<group />)
})
expect(state.getState().viewport.initialDpr).toEqual(2)
expect(state.getState().performance.min).toEqual(0.2)
expect(state.getState().performance.current).toEqual(1)
await act(async () => {
state.getState().setDpr(0.1)
})
expect(state.getState().viewport.dpr).toEqual(0.1)
jest.useFakeTimers()
await act(async () => {
state.getState().performance.regress()
jest.advanceTimersByTime(100)
})
expect(state.getState().performance.current).toEqual(0.2)
await act(async () => {
jest.advanceTimersByTime(200)
})
expect(state.getState().performance.current).toEqual(1)
jest.useRealTimers()
})
it('should set PCFSoftShadowMap as the default shadow map', async () => {
let state: UseBoundStore<RootState> = null!
await act(async () => {
state = root.configure({ shadows: true }).render(<group />)
})
expect(state.getState().gl.shadowMap.type).toBe(THREE.PCFSoftShadowMap)
})
it('should set tonemapping to ACESFilmicToneMapping and outputEncoding to sRGBEncoding if linear is false', async () => {
let state: UseBoundStore<RootState> = null!
await act(async () => {
state = root.configure({ linear: false }).render(<group />)
})
expect(state.getState().gl.toneMapping).toBe(THREE.ACESFilmicToneMapping)
expect(state.getState().gl.outputEncoding).toBe(THREE.sRGBEncoding)
})
it('should toggle render mode in xr', async () => {
let state: RootState = null!
await act(async () => {
state = root.render(<group />).getState()
state.gl.xr.isPresenting = true
state.gl.xr.dispatchEvent({ type: 'sessionstart' })
})
expect(state.gl.xr.enabled).toEqual(true)
await act(async () => {
state.gl.xr.isPresenting = false
state.gl.xr.dispatchEvent({ type: 'sessionend' })
})
expect(state.gl.xr.enabled).toEqual(false)
})
it('should respect frameloop="never" in xr', async () => {
let respected = true
await act(async () => {
const TestGroup = () => {
useFrame(() => (respected = false))
return <group />
}
const state = root
.configure({ frameloop: 'never' })
.render(<TestGroup />)
.getState()
state.gl.xr.isPresenting = true
state.gl.xr.dispatchEvent({ type: 'sessionstart' })
})
expect(respected).toEqual(true)
})
it('will render components that are extended', async () => {
const testExtend = async () => {
await act(async () => {
extend({ MyColor })
root.render(<myColor args={[0x0000ff]} />)
})
}
expect(() => testExtend()).not.toThrow()
})
it('should set renderer props via gl prop', async () => {
let gl: THREE.WebGLRenderer = null!
await act(async () => {
gl = root
.configure({ gl: { physicallyCorrectLights: true } })
.render(<group />)
.getState().gl
})
expect(gl.physicallyCorrectLights).toBe(true)
})
it('should update scene via scene prop', async () => {
let scene: THREE.Scene = null!
await act(async () => {
scene = root
.configure({ scene: { name: 'test' } })
.render(<group />)
.getState().scene
})
expect(scene.name).toBe('test')
})
it('should set a custom scene via scene prop', async () => {
let scene: THREE.Scene = null!
const prop = new THREE.Scene()
await act(async () => {
scene = root
.configure({ scene: prop })
.render(<group />)
.getState().scene
})
expect(prop).toBe(scene)
})
it('should set a renderer via gl callback', async () => {
class Renderer extends THREE.WebGLRenderer {}
let gl: Renderer = null!
await act(async () => {
gl = root
.configure({ gl: (canvas) => new Renderer({ canvas }) })
.render(<group />)
.getState().gl
})
expect(gl instanceof Renderer).toBe(true)
})
it('should respect color management preferences via gl', async () => {
const texture = new THREE.Texture() as THREE.Texture & { colorSpace?: string }
let key = 0
function Test() {
return <meshBasicMaterial key={key++} map={texture} />
}
const LinearEncoding = 3000
const sRGBEncoding = 3001
let gl: THREE.WebGLRenderer & { outputColorSpace?: string } = null!
await act(async () => (gl = root.render(<Test />).getState().gl))
expect(gl.outputEncoding).toBe(sRGBEncoding)
expect(gl.toneMapping).toBe(THREE.ACESFilmicToneMapping)
expect(texture.encoding).toBe(sRGBEncoding)
await act(async () => root.configure({ linear: true, flat: true }).render(<Test />))
expect(gl.outputEncoding).toBe(LinearEncoding)
expect(gl.toneMapping).toBe(THREE.NoToneMapping)
expect(texture.encoding).toBe(LinearEncoding)
// Sets outputColorSpace since r152
const SRGBColorSpace = 'srgb'
const LinearSRGBColorSpace = 'srgb-linear'
gl.outputColorSpace ??= ''
texture.colorSpace ??= ''
await act(async () => root.configure({ linear: true }).render(<Test />))
expect(gl.outputColorSpace).toBe(LinearSRGBColorSpace)
expect(texture.colorSpace).toBe(LinearSRGBColorSpace)
await act(async () => root.configure({ linear: false }).render(<Test />))
expect(gl.outputColorSpace).toBe(SRGBColorSpace)
expect(texture.colorSpace).toBe(SRGBColorSpace)
})
it('should respect legacy prop', async () => {
// <= r138 internal fallback
const material = React.createRef<THREE.MeshBasicMaterial>()
extend({ ColorManagement: null })
await act(async () => root.render(<meshBasicMaterial ref={material} color="#111111" />))
expect((THREE as any).ColorManagement.legacyMode).toBe(false)
expect(material.current!.color.toArray()).toStrictEqual(new THREE.Color('#111111').convertSRGBToLinear().toArray())
extend({ ColorManagement: (THREE as any).ColorManagement })
// r139 legacyMode
await act(async () => {
root.configure({ legacy: true }).render(<group />)
})
expect((THREE as any).ColorManagement.legacyMode).toBe(true)
await act(async () => {
root.configure({ legacy: false }).render(<group />)
})
expect((THREE as any).ColorManagement.legacyMode).toBe(false)
// r150 !enabled
;(THREE as any).ColorManagement.enabled = true
await act(async () => {
root.configure({ legacy: true }).render(<group />)
})
expect((THREE as any).ColorManagement.enabled).toBe(false)
await act(async () => {
root.configure({ legacy: false }).render(<group />)
})
expect((THREE as any).ColorManagement.enabled).toBe(true)
})
it('can handle createPortal', async () => {
const scene = new THREE.Scene()
let state: RootState = null!
let portalState: RootState = null!
const Normal = () => {
const three = useThree()
state = three
return <group />
}
const Portal = () => {
const three = useThree()
portalState = three
return <group />
}
await act(async () => {
root.render(
<>
<Normal />
{createPortal(<Portal />, scene, { scene })}
</>,
)
})
// Renders into portal target
expect(scene.children.length).not.toBe(0)
// Creates an isolated state enclave
expect(state.scene).not.toBe(scene)
expect(portalState.scene).toBe(scene)
// Preserves internal keys
const overwrittenKeys = ['get', 'set', 'events', 'size', 'viewport']
const respectedKeys = privateKeys.filter((key) => overwrittenKeys.includes(key) || state[key] === portalState[key])
expect(respectedKeys).toStrictEqual(privateKeys)
})
it('can handle createPortal on unmounted container', async () => {
let groupHandle!: THREE.Group | null
function Test(props: any) {
const [group, setGroup] = React.useState(null)
groupHandle = group
return (
<group {...props} ref={setGroup}>
{group && createPortal(<mesh />, group)}
</group>
)
}
await act(async () => root.render(<Test key={0} />))
expect(groupHandle).toBeDefined()
const prevUUID = groupHandle!.uuid
await act(async () => root.render(<Test key={1} />))
expect(groupHandle).toBeDefined()
expect(prevUUID).not.toBe(groupHandle!.uuid)
})
it('invalidates pierced props when root is changed', async () => {
const material = React.createRef<THREE.MeshBasicMaterial>()
const texture1 = { needsUpdate: false, name: '' } as THREE.Texture
const texture2 = { needsUpdate: false, name: '' } as THREE.Texture
await act(async () =>
root.render(<meshBasicMaterial ref={material} map={texture1} map-needsUpdate={true} map-name="test" />),
)
expect(material.current!.map).toBe(texture1)
expect(texture1.needsUpdate).toBe(true)
expect(texture1.name).toBe('test')
await act(async () =>
root.render(<meshBasicMaterial ref={material} map={texture2} map-needsUpdate={true} map-name="test" />),
)
expect(material.current!.map).toBe(texture2)
expect(texture2.needsUpdate).toBe(true)
expect(texture2.name).toBe('test')
})
// https://github.com/mrdoob/three.js/issues/21209
it("can handle HMR default where three.js isn't reliable", async () => {
const ref = React.createRef<THREE.Mesh>()
function Test() {
const [scale, setScale] = React.useState(true)
const props: any = {}
if (scale) props.scale = 0.5
React.useEffect(() => void setScale(false), [])
return <mesh ref={ref} {...props} />
}
await act(async () => root.render(<Test />))
expect(ref.current!.scale.toArray()).toStrictEqual(new THREE.Object3D().scale.toArray())
})
it("onUpdate shouldn't update itself", async () => {
const one = jest.fn()
const two = jest.fn()
const Test = (props: Partial<JSX.IntrinsicElements['mesh']>) => <mesh {...props} />
await act(async () => root.render(<Test onUpdate={one} />))
await act(async () => root.render(<Test onUpdate={two} />))
expect(one).toBeCalledTimes(1)
expect(two).toBeCalledTimes(0)
})
it("camera props shouldn't overwrite state", async () => {
const camera = new THREE.OrthographicCamera()
function Test() {
const set = useThree((state) => state.set)
React.useMemo(() => set({ camera }), [set])
return null
}
const store = await act(async () => root.render(<Test />))
expect(store.getState().camera).toBe(camera)
root.configure({ camera: { name: 'test' } })
await act(async () => root.render(<Test />))
expect(store.getState().camera).toBe(camera)
expect(camera.name).not.toBe('test')
})
it('should safely handle updates to the object prop', async () => {
const ref = React.createRef<THREE.Object3D>()
const child = React.createRef<THREE.Object3D>()
const attachedChild = React.createRef<THREE.Object3D>()
const Test = (props: JSX.IntrinsicElements['primitive']) => (
<primitive {...props} ref={ref}>
<object3D ref={child} />
<object3D ref={attachedChild} attach="userData-attach" />
</primitive>
)
const object1 = new THREE.Object3D()
const child1 = new THREE.Object3D()
object1.add(child1)
const object2 = new THREE.Object3D()
const child2 = new THREE.Object3D()
object2.add(child2)
// Initial
await act(async () => root.render(<Test object={object1} />))
expect(ref.current).toBe(object1)
expect(ref.current!.children).toStrictEqual([child1, child.current])
expect(ref.current!.userData.attach).toBe(attachedChild.current)
// Update
await act(async () => root.render(<Test object={object2} />))
expect(ref.current).toBe(object2)
expect(ref.current!.children).toStrictEqual([child2, child.current])
expect(ref.current!.userData.attach).toBe(attachedChild.current)
// Revert
await act(async () => root.render(<Test object={object1} />))
expect(ref.current).toBe(object1)
expect(ref.current!.children).toStrictEqual([child1, child.current])
expect(ref.current!.userData.attach).toBe(attachedChild.current)
})
it('should recursively dispose of declarative children', async () => {
const parentDispose = jest.fn()
const childDispose = jest.fn()
await act(async () =>
root.render(
<mesh dispose={parentDispose}>
<mesh dispose={childDispose} />
</mesh>,
),
)
await act(async () => root.render(null))
expect(parentDispose).toBeCalledTimes(1)
expect(childDispose).toBeCalledTimes(1)
})
it('should not recursively dispose of flagged parent', async () => {
const parentDispose = jest.fn()
const childDispose = jest.fn()
await act(async () =>
root.render(
<group dispose={null}>
<mesh dispose={parentDispose}>
<mesh dispose={childDispose} />
</mesh>
</group>,
),
)
await act(async () => root.render(null))
expect(parentDispose).not.toBeCalled()
expect(childDispose).not.toBeCalled()
})
it('should not recursively dispose of attached primitives', async () => {
const meshDispose = jest.fn()
const primitiveDispose = jest.fn()
await act(async () =>
root.render(
<mesh dispose={meshDispose}>
<primitive dispose={primitiveDispose} object={new THREE.BufferGeometry()} attach="geometry" />
</mesh>,
),
)
await act(async () => root.render(null))
expect(meshDispose).toBeCalledTimes(1)
expect(primitiveDispose).not.toBeCalled()
})
})
|
6,620 | 0 | petrpan-code/pmndrs/react-three-fiber/packages/fiber/tests | petrpan-code/pmndrs/react-three-fiber/packages/fiber/tests/core/utils.test.ts | import { is } from '../../src/core/utils'
describe('is', () => {
const myFunc = () => null
const myObj = { myProp: 'test-prop' }
const myStr = 'test-string'
const myNum = 1
const myUnd = undefined
const myArr = [1, 2, 3]
it('should tell me if something IS a function', () => {
expect(is.fun(myFunc)).toBe(true)
expect(is.fun(myObj)).toBe(false)
expect(is.fun(myStr)).toBe(false)
expect(is.fun(myNum)).toBe(false)
expect(is.fun(myUnd)).toBe(false)
expect(is.fun(myArr)).toBe(false)
})
it('should tell me if something IS an object', () => {
expect(is.obj(myFunc)).toBe(false)
expect(is.obj(myObj)).toBe(true)
expect(is.obj(myStr)).toBe(false)
expect(is.obj(myNum)).toBe(false)
expect(is.obj(myUnd)).toBe(false)
expect(is.obj(myArr)).toBe(false)
})
it('should tell me if something IS a string', () => {
expect(is.str(myFunc)).toBe(false)
expect(is.str(myObj)).toBe(false)
expect(is.str(myStr)).toBe(true)
expect(is.str(myNum)).toBe(false)
expect(is.str(myUnd)).toBe(false)
expect(is.str(myArr)).toBe(false)
})
it('should tell me if something IS a number', () => {
expect(is.num(myFunc)).toBe(false)
expect(is.num(myObj)).toBe(false)
expect(is.num(myStr)).toBe(false)
expect(is.num(myNum)).toBe(true)
expect(is.num(myUnd)).toBe(false)
expect(is.num(myArr)).toBe(false)
})
it('should tell me if something IS undefined', () => {
expect(is.und(myFunc)).toBe(false)
expect(is.und(myObj)).toBe(false)
expect(is.und(myStr)).toBe(false)
expect(is.und(myNum)).toBe(false)
expect(is.und(myUnd)).toBe(true)
expect(is.und(myArr)).toBe(false)
})
it('should tell me if something is an array', () => {
expect(is.arr(myFunc)).toBe(false)
expect(is.arr(myObj)).toBe(false)
expect(is.arr(myStr)).toBe(false)
expect(is.arr(myNum)).toBe(false)
expect(is.arr(myUnd)).toBe(false)
expect(is.arr(myArr)).toBe(true)
})
it('should tell me if something is equal', () => {
expect(is.equ([], '')).toBe(false)
expect(is.equ('hello', 'hello')).toBe(true)
expect(is.equ(1, 1)).toBe(true)
const obj = { type: 'Mesh' }
expect(is.equ(obj, obj)).toBe(true)
expect(is.equ({}, {})).toBe(false)
expect(is.equ({}, {}, { objects: 'reference' })).toBe(false)
expect(is.equ({}, {}, { objects: 'shallow' })).toBe(true)
expect(is.equ({ a: 1 }, { a: 1 })).toBe(false)
expect(is.equ({ a: 1 }, { a: 1 }, { objects: 'reference' })).toBe(false)
expect(is.equ({ a: 1 }, { a: 1 }, { objects: 'shallow' })).toBe(true)
expect(is.equ({ a: 1, b: 1 }, { a: 1 }, { objects: 'shallow' })).toBe(false)
expect(is.equ({ a: 1 }, { a: 1, b: 1 }, { objects: 'shallow' })).toBe(false)
expect(is.equ({ a: 1 }, { a: 1, b: 1 }, { objects: 'shallow', strict: false })).toBe(true)
expect(is.equ({ a: [1, 2, 3] }, { a: [1, 2, 3] }, { arrays: 'reference', objects: 'reference' })).toBe(false)
expect(is.equ({ a: [1, 2, 3] }, { a: [1, 2, 3] }, { objects: 'reference' })).toBe(false)
expect(is.equ({ a: [1, 2, 3] }, { a: [1, 2, 3] }, { objects: 'shallow' })).toBe(true)
expect(is.equ({ a: [1, 2, 3] }, { a: [1, 2, 3, 4] }, { objects: 'shallow' })).toBe(false)
expect(is.equ({ a: [1, 2, 3] }, { a: [1, 2, 3, 4] }, { objects: 'shallow', strict: false })).toBe(true)
expect(is.equ({ a: [1, 2, 3] }, { a: [1, 2, 3], b: 1 }, { objects: 'shallow' })).toBe(false)
expect(is.equ({ a: [1, 2, 3] }, { a: [1, 2, 3], b: 1 }, { objects: 'shallow', strict: false })).toBe(true)
const arr = [1, 2, 3]
expect(is.equ(arr, arr)).toBe(true)
expect(is.equ([], [])).toBe(true)
expect(is.equ([], [], { arrays: 'reference' })).toBe(false)
expect(is.equ([], [], { arrays: 'shallow' })).toBe(true)
expect(is.equ([1, 2, 3], [1, 2, 3])).toBe(true)
expect(is.equ([1, 2, 3], [1, 2, 3], { arrays: 'shallow' })).toBe(true)
expect(is.equ([1, 2, 3], [1, 2, 3], { arrays: 'reference' })).toBe(false)
expect(is.equ([1, 2], [1, 2, 3])).toBe(false)
expect(is.equ([1, 2, 3, 4], [1, 2, 3])).toBe(false)
expect(is.equ([1, 2], [1, 2, 3], { strict: false })).toBe(true)
})
})
|
6,621 | 0 | petrpan-code/pmndrs/react-three-fiber/packages/fiber/tests | petrpan-code/pmndrs/react-three-fiber/packages/fiber/tests/native/canvas.test.tsx | import * as React from 'react'
import { View } from 'react-native'
import { act, create, ReactTestRenderer } from 'react-test-renderer'
import { Canvas } from '../../src/native'
describe('native Canvas', () => {
it('should correctly mount', async () => {
let renderer: ReactTestRenderer = null!
await act(async () => {
renderer = create(
<Canvas>
<group />
</Canvas>,
)
})
expect(renderer.toJSON()).toMatchSnapshot()
})
it('should forward ref', async () => {
const ref = React.createRef<View>()
await act(async () => {
create(
<Canvas ref={ref}>
<group />
</Canvas>,
)
})
expect(ref.current).toBeDefined()
})
it('should correctly unmount', async () => {
let renderer: ReactTestRenderer = null!
await act(async () => {
renderer = create(
<Canvas>
<group />
</Canvas>,
)
})
expect(() => renderer.unmount()).not.toThrow()
})
})
|
6,622 | 0 | petrpan-code/pmndrs/react-three-fiber/packages/fiber/tests | petrpan-code/pmndrs/react-three-fiber/packages/fiber/tests/native/polyfills.test.ts | import * as THREE from 'three'
import { polyfills } from '../../src/native/polyfills'
polyfills()
const pixel =
'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII='
describe('polyfills', () => {
it('loads images via data textures', async () => {
const texture = await new THREE.TextureLoader().loadAsync(pixel)
expect((texture as any).isDataTexture).toBe(true)
expect(texture.image.width).toBe(1)
expect(texture.image.height).toBe(1)
})
it('creates a safe image URI for JSI', async () => {
const texture = await new THREE.TextureLoader().loadAsync(pixel)
expect(texture.image.data.localUri.startsWith('file:///')).toBe(true)
})
it('unpacks drawables in Android APK', async () => {
const texture = await new THREE.TextureLoader().loadAsync('drawable.png')
expect(texture.image.data.localUri.includes(':')).toBe(true)
})
it('loads files via the file system', async () => {
const asset = 1
const file = await new THREE.FileLoader().loadAsync(asset as any)
expect(typeof (file as ArrayBuffer).byteLength).toBe('number') // TODO: ArrayBuffer instanceof
})
it('loads files via http', async () => {
const file = await new THREE.FileLoader().loadAsync('https://example.com/test.png')
expect(typeof (file as ArrayBuffer).byteLength).toBe('number') // TODO: ArrayBuffer instanceof
})
})
|
6,623 | 0 | petrpan-code/pmndrs/react-three-fiber/packages/fiber/tests/native | petrpan-code/pmndrs/react-three-fiber/packages/fiber/tests/native/__snapshots__/canvas.test.tsx.snap | // Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`native Canvas should correctly mount 1`] = `null`;
|
6,624 | 0 | petrpan-code/pmndrs/react-three-fiber/packages/fiber/tests | petrpan-code/pmndrs/react-three-fiber/packages/fiber/tests/web/canvas.test.tsx | // use default export for jest.spyOn
import React from 'react'
import { render, RenderResult } from '@testing-library/react'
import { Canvas, act } from '../../src'
describe('web Canvas', () => {
it('should correctly mount', async () => {
let renderer: RenderResult = null!
await act(async () => {
renderer = render(
<Canvas>
<group />
</Canvas>,
)
})
expect(renderer.container).toMatchSnapshot()
})
it('should forward ref', async () => {
const ref = React.createRef<HTMLCanvasElement>()
await act(async () => {
render(
<Canvas ref={ref}>
<group />
</Canvas>,
)
})
expect(ref.current).toBeDefined()
})
it('should correctly unmount', async () => {
let renderer: RenderResult = null!
await act(async () => {
renderer = render(
<Canvas>
<group />
</Canvas>,
)
})
expect(() => renderer.unmount()).not.toThrow()
})
it('plays nice with react SSR', async () => {
const useLayoutEffect = jest.spyOn(React, 'useLayoutEffect')
await act(async () => {
render(
<Canvas>
<group />
</Canvas>,
)
})
expect(useLayoutEffect).not.toHaveBeenCalled()
})
})
|
6,625 | 0 | petrpan-code/pmndrs/react-three-fiber/packages/fiber/tests/web | petrpan-code/pmndrs/react-three-fiber/packages/fiber/tests/web/__snapshots__/canvas.test.tsx.snap | // Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`web Canvas should correctly mount 1`] = `
<div>
<div
style="position: relative; width: 100%; height: 100%; overflow: hidden; pointer-events: auto;"
>
<div
style="width: 100%; height: 100%;"
>
<canvas
data-engine="three.js r139"
height="800"
style="display: block; width: 1280px; height: 800px;"
width="1280"
/>
</div>
</div>
</div>
`;
|
6,640 | 0 | petrpan-code/pmndrs/react-three-fiber/packages/test-renderer/src | petrpan-code/pmndrs/react-three-fiber/packages/test-renderer/src/__tests__/RTTR.core.test.tsx | import { useFrame } from '@react-three/fiber'
import * as React from 'react'
import * as THREE from 'three'
import ReactThreeTestRenderer from '../index'
type ExampleComp = THREE.Mesh<THREE.BoxBufferGeometry, THREE.Material>
describe('ReactThreeTestRenderer Core', () => {
it('renders JSX', async () => {
const Mesh = () => {
return (
<mesh>
<boxGeometry args={[2, 2]} />
<meshBasicMaterial />
</mesh>
)
}
const renderer = await ReactThreeTestRenderer.create(<Mesh />)
expect(renderer.scene.children[0].type).toEqual('Mesh')
await renderer.update(<Mesh />)
expect(renderer.scene.children[0].type).toEqual('Mesh')
})
it('renders a simple component with hooks', async () => {
const Mesh = () => {
const meshRef = React.useRef<THREE.Mesh<THREE.BoxGeometry, THREE.MeshBasicMaterial>>()
useFrame(() => void (meshRef.current!.position.x += 0.01))
return (
<mesh>
<boxGeometry args={[2, 2]} />
<meshBasicMaterial />
</mesh>
)
}
const renderer = await ReactThreeTestRenderer.create(<Mesh />)
expect(renderer.scene.children[0].type).toEqual('Mesh')
await renderer.update(<Mesh />)
expect(renderer.scene.children[0].type).toEqual('Mesh')
})
it('renders a simple component with useTransition', async () => {
const Mesh = () => {
const [name, setName] = React.useState<string>()
React.useLayoutEffect(() => {
;(React as any).startTransition(() => void setName('mesh'))
})
return (
<mesh name={name}>
<boxGeometry args={[2, 2]} />
<meshBasicMaterial />
</mesh>
)
}
const renderer = await ReactThreeTestRenderer.create(
<React.Suspense fallback={null}>
<Mesh />
</React.Suspense>,
)
expect(renderer.scene.children[0].props.name).toEqual('mesh')
})
it('renders an empty scene', async () => {
const Empty = () => {
return null
}
const renderer = await ReactThreeTestRenderer.create(<Empty />)
expect(renderer.scene.type).toEqual('Scene')
expect(renderer.scene.children).toEqual([])
expect(renderer.toGraph()).toEqual([])
})
it('can render a composite component & correctly build simple graph', async () => {
class Parent extends React.Component {
render() {
return (
<group>
<color attach="background" args={[0, 0, 0]} />
<Child />
</group>
)
}
}
const Child = () => {
return (
<mesh>
<boxGeometry args={[2, 2]} />
<meshBasicMaterial />
</mesh>
)
}
const renderer = await ReactThreeTestRenderer.create(<Parent />)
expect(renderer.toGraph()).toEqual([
{
type: 'Group',
name: '',
children: [
{
type: 'Mesh',
name: '',
children: [],
},
],
},
])
})
it('renders some basics with an update', async () => {
let renders = 0
class Component extends React.PureComponent {
state = {
pos: 3,
}
componentDidMount() {
this.setState({
pos: 7,
})
}
render() {
renders++
return (
<group position-x={this.state.pos}>
<Child />
<Null />
</group>
)
}
}
const Child = () => {
renders++
return <color attach="background" args={[0, 0, 0]} />
}
const Null = () => {
renders++
return null
}
const renderer = await ReactThreeTestRenderer.create(<Component />)
expect(renderer.scene.children[0].instance.position.x).toEqual(7)
expect(renders).toBe(6)
})
it('updates types & names', async () => {
const renderer = await ReactThreeTestRenderer.create(
<mesh>
<meshBasicMaterial name="basicMat">
<color attach="color" args={[0, 0, 0]} />
</meshBasicMaterial>
</mesh>,
)
let childInstance = renderer.scene.children[0].instance as ExampleComp
expect(childInstance.material.type).toEqual('MeshBasicMaterial')
expect(childInstance.material.name).toEqual('basicMat')
await renderer.update(
<mesh>
<meshStandardMaterial name="standardMat">
<color attach="color" args={[255, 255, 255]} />
</meshStandardMaterial>
</mesh>,
)
childInstance = renderer.scene.children[0].instance as ExampleComp
expect(childInstance.material.type).toEqual('MeshStandardMaterial')
expect(childInstance.material.name).toEqual('standardMat')
})
it('exposes the instance', async () => {
class Mesh extends React.PureComponent {
state = { standardMat: false }
handleStandard() {
this.setState({ standardMat: true })
}
render() {
return (
<mesh>
<boxGeometry args={[2, 2]} />
{this.state.standardMat ? <meshStandardMaterial /> : <meshBasicMaterial />}
</mesh>
)
}
}
const renderer = await ReactThreeTestRenderer.create(<Mesh />)
expect(renderer.toTree()).toEqual([
{
type: 'mesh',
props: {
args: [],
},
children: [
{ type: 'boxGeometry', props: { args: [2, 2] }, children: [] },
{
type: 'meshBasicMaterial',
props: {
args: [],
},
children: [],
},
],
},
])
const instance = renderer.getInstance() as Mesh
await ReactThreeTestRenderer.act(async () => {
instance.handleStandard()
})
expect(renderer.toTree()).toEqual([
{
type: 'mesh',
props: {
args: [],
},
children: [
{ type: 'boxGeometry', props: { args: [2, 2] }, children: [] },
{
type: 'meshStandardMaterial',
props: {
args: [],
},
children: [],
},
],
},
])
})
it('updates children', async () => {
const renderer = await ReactThreeTestRenderer.create(
<group>
<mesh key="a" position-z={12}>
<boxGeometry args={[2, 2]} />
<meshBasicMaterial />
</mesh>
<mesh key="b" position-y={12}>
<boxGeometry args={[4, 4]} />
<meshBasicMaterial />
</mesh>
<mesh key="c" position-x={12}>
<boxGeometry args={[6, 6]} />
<meshBasicMaterial />
</mesh>
</group>,
)
expect(renderer.toTree()).toMatchSnapshot()
await renderer.update(
<group>
<mesh key="d" rotation-x={1}>
<boxGeometry args={[6, 6]} />
<meshBasicMaterial />
</mesh>
<mesh key="b" position-y={12}>
<boxGeometry args={[4, 4]} />
<meshBasicMaterial />
</mesh>
<mesh key="c" position-x={12}>
<boxGeometry args={[2, 2]} />
<meshBasicMaterial />
</mesh>
</group>,
)
expect(renderer.toTree()).toMatchSnapshot()
})
it('does the full lifecycle', async () => {
const log: string[] = []
class Log extends React.Component<{ name: string }> {
render() {
log.push('render ' + this.props.name)
return (
<mesh>
<boxGeometry args={[2, 2]} />
<meshStandardMaterial />
</mesh>
)
}
componentDidMount() {
log.push('mount ' + this.props.name)
}
componentWillUnmount() {
log.push('unmount ' + this.props.name)
}
}
const renderer = await ReactThreeTestRenderer.create(<Log key="foo" name="Foo" />)
await renderer.update(<Log key="bar" name="Bar" />)
await renderer.unmount()
expect(log).toEqual(['render Foo', 'mount Foo', 'render Bar', 'unmount Foo', 'mount Bar', 'unmount Bar'])
})
it('gives a ref to native components', async () => {
const log: THREE.Mesh[] = []
await ReactThreeTestRenderer.create(<mesh ref={(r) => log.push(r as THREE.Mesh)} />)
expect(log.length).toEqual(1)
expect(log[0].type).toEqual('Mesh')
})
it('toTree() handles nested Fragments', async () => {
const Component = () => (
<>
<>
<group />
</>
</>
)
const renderer = await ReactThreeTestRenderer.create(<Component />)
expect(renderer.toTree()).toEqual([
{
type: 'group',
props: {
args: [],
},
children: [],
},
])
})
it('correctly builds a tree', async () => {
const Component = () => {
return (
<group position={[1, 2, 3]}>
<Child col={[0, 0, 255]} />
<Mesh />
<Null />
</group>
)
}
const vertices = new Float32Array([
-1.0, -1.0, 1.0, 1.0, -1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, -1.0, 1.0, 1.0, -1.0, -1.0, 1.0,
])
const Mesh = () => {
return (
<mesh>
<bufferGeometry attach="geometry">
<bufferAttribute attach="attributes-position" array={vertices} count={vertices.length / 3} itemSize={3} />
</bufferGeometry>
<meshBasicMaterial attach="material" color="hotpink" />
</mesh>
)
}
const Child = ({ col }: { col: [number, number, number] }) => {
return <color attach="background" args={col} />
}
const Null = () => {
return null
}
const renderer = await ReactThreeTestRenderer.create(<Component />)
expect(renderer.toTree()).toMatchSnapshot()
})
it('toTree() handles complicated tree of fragments', async () => {
const renderer = await ReactThreeTestRenderer.create(
<>
<>
<group>
<color attach="background" args={[0, 0, 0]} />
</group>
<>
<group>
<color attach="background" args={[0, 0, 255]} />
</group>
</>
</>
<group>
<color attach="background" args={[255, 0, 0]} />
</group>
</>,
)
expect(renderer.toTree()).toMatchSnapshot()
})
it('root instance and refs return the same value', async () => {
let refInst = null
const renderer = await ReactThreeTestRenderer.create(<mesh ref={(ref) => (refInst = ref)} />)
const root = renderer.getInstance() // this will be Mesh
expect(root).toEqual(refInst)
})
})
|
6,641 | 0 | petrpan-code/pmndrs/react-three-fiber/packages/test-renderer/src | petrpan-code/pmndrs/react-three-fiber/packages/test-renderer/src/__tests__/RTTR.events.test.tsx | import * as React from 'react'
import ReactThreeTestRenderer from '../index'
import type { ReactThreeTest } from '../index'
describe('ReactThreeTestRenderer Events', () => {
it('should fire an event', async () => {
const handlePointerDown = jest.fn().mockImplementationOnce((event: ReactThreeTest.MockSyntheticEvent) => {
expect(() => event.stopPropagation()).not.toThrow()
expect(event.offsetX).toEqual(640)
expect(event.offsetY).toEqual(400)
})
const Component = () => {
return (
<mesh onPointerDown={handlePointerDown}>
<boxGeometry args={[2, 2]} />
<meshBasicMaterial />
</mesh>
)
}
const { scene, fireEvent } = await ReactThreeTestRenderer.create(<Component />)
const eventData = {
offsetX: 640,
offsetY: 400,
}
await fireEvent(scene.children[0], 'onPointerDown', eventData)
expect(handlePointerDown).toHaveBeenCalledTimes(1)
await fireEvent(scene.children[0], 'pointerDown')
expect(handlePointerDown).toHaveBeenCalledTimes(2)
})
it('should not throw if the handle name is incorrect', async () => {
const handlePointerDown = jest.fn()
const Component = () => {
return (
<mesh onPointerDown={handlePointerDown}>
<boxGeometry args={[2, 2]} />
<meshBasicMaterial />
</mesh>
)
}
const { scene, fireEvent } = await ReactThreeTestRenderer.create(<Component />)
expect(async () => await fireEvent(scene.children[0], 'onPointerUp')).not.toThrow()
expect(handlePointerDown).not.toHaveBeenCalled()
})
})
|
6,642 | 0 | petrpan-code/pmndrs/react-three-fiber/packages/test-renderer/src | petrpan-code/pmndrs/react-three-fiber/packages/test-renderer/src/__tests__/RTTR.hooks.test.tsx | import * as React from 'react'
import * as Stdlib from 'three-stdlib'
import * as THREE from 'three'
import { useFrame, useLoader, useThree } from '@react-three/fiber'
import { waitFor } from '@react-three/test-renderer'
import ReactThreeTestRenderer from '../index'
describe('ReactThreeTestRenderer Hooks', () => {
it('can handle useThree hook', async () => {
let result = {} as {
camera: THREE.Camera
scene: THREE.Scene
raycaster: THREE.Raycaster
size: { width: number; height: number }
}
const Component = () => {
const res = useThree((state) => ({
camera: state.camera,
scene: state.scene,
size: state.size,
raycaster: state.raycaster,
}))
result = res
return <group />
}
await ReactThreeTestRenderer.create(<Component />)
expect(result.camera instanceof THREE.Camera).toBeTruthy()
expect(result.scene instanceof THREE.Scene).toBeTruthy()
expect(result.raycaster instanceof THREE.Raycaster).toBeTruthy()
expect(result.size).toEqual({ height: 0, width: 0, top: 0, left: 0, updateStyle: false })
})
it('can handle useLoader hook', async () => {
const MockMesh = new THREE.Mesh()
jest.spyOn(Stdlib, 'GLTFLoader').mockImplementation(
() =>
({
load: jest.fn().mockImplementation((_url, onLoad) => {
onLoad(MockMesh)
}),
} as unknown as Stdlib.GLTFLoader),
)
const Component = () => {
const model = useLoader(Stdlib.GLTFLoader, '/suzanne.glb')
return <primitive object={model} />
}
const renderer = await ReactThreeTestRenderer.create(
<React.Suspense fallback={null}>
<Component />
</React.Suspense>,
)
await waitFor(() => expect(renderer.scene.children[0]).toBeDefined())
expect(renderer.scene.children[0].instance).toBe(MockMesh)
})
it('can handle useFrame hook using test renderers advanceFrames function', async () => {
const Component = () => {
const meshRef = React.useRef<THREE.Mesh>(null!)
useFrame((_, delta) => {
meshRef.current.rotation.x += delta
})
return (
<mesh ref={meshRef}>
<boxGeometry args={[2, 2]} />
<meshBasicMaterial />
</mesh>
)
}
const renderer = await ReactThreeTestRenderer.create(<Component />)
expect(renderer.scene.children[0].instance.rotation.x).toEqual(0)
await ReactThreeTestRenderer.act(async () => {
await renderer.advanceFrames(2, 1)
})
expect(renderer.scene.children[0].instance.rotation.x).toEqual(2)
})
})
|
6,643 | 0 | petrpan-code/pmndrs/react-three-fiber/packages/test-renderer/src | petrpan-code/pmndrs/react-three-fiber/packages/test-renderer/src/__tests__/RTTR.methods.test.tsx | import * as React from 'react'
import ReactThreeTestRenderer from '../index'
describe('ReactThreeTestRenderer instance methods', () => {
const ExampleComponent = () => {
return (
<group>
<mesh name="mesh_01">
<boxGeometry args={[2, 2]} />
<meshStandardMaterial color={0x0000ff} />
</mesh>
<mesh name="mesh_02">
<boxGeometry args={[2, 2]} />
<meshBasicMaterial color={0x0000ff} />
</mesh>
</group>
)
}
it('should pass the parent', async () => {
const { scene } = await ReactThreeTestRenderer.create(<ExampleComponent />)
expect(scene.parent).toBeNull()
expect(scene.children[0].parent).toBeDefined()
expect(scene.children[0].parent!.type).toEqual('Scene')
})
it('searches via .find() / .findAll()', async () => {
const { scene } = await ReactThreeTestRenderer.create(<ExampleComponent />)
const foundByName = scene.find((node) => node.instance.name === 'mesh_01')
expect(foundByName.type).toEqual('Mesh')
const foundAllByColor = scene.findAll((node) => node.props.color === 0x0000ff)
expect(foundAllByColor).toHaveLength(2)
expect(foundAllByColor[0].type).toEqual('MeshStandardMaterial')
expect(foundAllByColor[1].type).toEqual('MeshBasicMaterial')
const foundAllByType = scene.findAll((node) => node.type === 'InstancedMesh')
expect(foundAllByType).toHaveLength(0)
expect(foundAllByType).toEqual([])
expect(() => scene.find((node) => node.props.color === 0x0000ff)).toThrow()
})
it('searches via .findByType() / findAllByType()', async () => {
const { scene } = await ReactThreeTestRenderer.create(<ExampleComponent />)
const foundByStandardMaterial = scene.findByType('MeshStandardMaterial')
expect(foundByStandardMaterial).toBeDefined()
const foundAllByMesh = scene.findAllByType('Mesh')
expect(foundAllByMesh).toHaveLength(2)
expect(foundAllByMesh[0].instance.name).toEqual('mesh_01')
expect(foundAllByMesh[1].instance.name).toEqual('mesh_02')
const foundAllByBoxBufferGeometry = scene.findAllByType('BoxBufferGeometry')
expect(foundAllByBoxBufferGeometry).toHaveLength(0)
expect(foundAllByBoxBufferGeometry).toEqual([])
expect(() => scene.findByType('BufferGeometry')).toThrow()
})
it('searches via .findByProps() / .findAllByProps()', async () => {
const { scene } = await ReactThreeTestRenderer.create(<ExampleComponent />)
const foundByName = scene.findByProps({
name: 'mesh_01',
})
expect(foundByName.type).toEqual('Mesh')
const foundAllByColor = scene.findAllByProps({
color: 0x0000ff,
})
expect(foundAllByColor).toHaveLength(2)
expect(foundAllByColor[0].type).toEqual('MeshStandardMaterial')
expect(foundAllByColor[1].type).toEqual('MeshBasicMaterial')
const foundAllByColorAndName = scene.findAllByProps({
color: 0x0000ff,
name: 'mesh_01',
})
expect(foundAllByColorAndName).toHaveLength(0)
expect(foundAllByColorAndName).toEqual([])
expect(() => scene.findByProps({ color: 0x0000ff })).toThrow()
})
it('searches RegExp via .findByProps() / .findAllByProps()', async () => {
const { scene } = await ReactThreeTestRenderer.create(<ExampleComponent />)
const single = scene.findByProps({
name: /^mesh_01$/,
})
expect(single.type).toEqual('Mesh')
const multiple = scene.findAllByProps({
name: /^mesh_\d+$/,
})
expect(multiple.length).toEqual(2)
})
})
|
6,644 | 0 | petrpan-code/pmndrs/react-three-fiber/packages/test-renderer/src | petrpan-code/pmndrs/react-three-fiber/packages/test-renderer/src/__tests__/is.test.ts | import { is } from '../helpers/is'
describe('is', () => {
const myFunc = () => {
return null
}
const myObj = {
myProp: 'test-prop',
}
const myStr = 'test-string'
const myNum = 1
const myUnd = undefined
const myArr = [1, 2, 3]
it('should tell me if something IS a function', () => {
expect(is.fun(myFunc)).toBe(true)
expect(is.fun(myObj)).toBe(false)
expect(is.fun(myStr)).toBe(false)
expect(is.fun(myNum)).toBe(false)
expect(is.fun(myUnd)).toBe(false)
expect(is.fun(myArr)).toBe(false)
})
it('should tell me if something IS an object', () => {
expect(is.obj(myFunc)).toBe(false)
expect(is.obj(myObj)).toBe(true)
expect(is.obj(myStr)).toBe(false)
expect(is.obj(myNum)).toBe(false)
expect(is.obj(myUnd)).toBe(false)
expect(is.obj(myArr)).toBe(false)
})
it('should tell me if something IS a string', () => {
expect(is.str(myFunc)).toBe(false)
expect(is.str(myObj)).toBe(false)
expect(is.str(myStr)).toBe(true)
expect(is.str(myNum)).toBe(false)
expect(is.str(myUnd)).toBe(false)
expect(is.str(myArr)).toBe(false)
})
it('should tell me if something IS a number', () => {
expect(is.num(myFunc)).toBe(false)
expect(is.num(myObj)).toBe(false)
expect(is.num(myStr)).toBe(false)
expect(is.num(myNum)).toBe(true)
expect(is.num(myUnd)).toBe(false)
expect(is.num(myArr)).toBe(false)
})
it('should tell me if something IS undefined', () => {
expect(is.und(myFunc)).toBe(false)
expect(is.und(myObj)).toBe(false)
expect(is.und(myStr)).toBe(false)
expect(is.und(myNum)).toBe(false)
expect(is.und(myUnd)).toBe(true)
expect(is.und(myArr)).toBe(false)
})
it('should tell me if something is an array', () => {
expect(is.arr(myFunc)).toBe(false)
expect(is.arr(myObj)).toBe(false)
expect(is.arr(myStr)).toBe(false)
expect(is.arr(myNum)).toBe(false)
expect(is.arr(myUnd)).toBe(false)
expect(is.arr(myArr)).toBe(true)
})
it('should tell me if something is equal', () => {
expect(is.equ([], '')).toBe(false)
expect(is.equ('hello', 'hello')).toBe(true)
expect(is.equ(1, 1)).toBe(true)
expect(is.equ(myObj, myObj)).toBe(true)
expect(is.equ(myArr, myArr)).toBe(true)
expect(is.equ([1, 2, 3], [1, 2, 3])).toBe(true)
})
})
|
6,645 | 0 | petrpan-code/pmndrs/react-three-fiber/packages/test-renderer/src/__tests__ | petrpan-code/pmndrs/react-three-fiber/packages/test-renderer/src/__tests__/__snapshots__/RTTR.core.test.tsx.snap | // Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`ReactThreeTestRenderer Core correctly builds a tree 1`] = `
Array [
Object {
"children": Array [
Object {
"children": Array [
Object {
"children": Array [
Object {
"children": Array [],
"props": Object {
"args": Array [],
"array": Float32Array [
-1,
-1,
1,
1,
-1,
1,
1,
1,
1,
1,
1,
1,
-1,
1,
1,
-1,
-1,
1,
],
"count": 6,
"itemSize": 3,
},
"type": "bufferAttribute",
},
],
"props": Object {
"args": Array [],
},
"type": "bufferGeometry",
},
Object {
"children": Array [],
"props": Object {
"args": Array [],
"color": "hotpink",
},
"type": "meshBasicMaterial",
},
],
"props": Object {
"args": Array [],
},
"type": "mesh",
},
Object {
"children": Array [],
"props": Object {
"args": Array [
0,
0,
255,
],
},
"type": "color",
},
],
"props": Object {
"args": Array [],
"position": Array [
1,
2,
3,
],
},
"type": "group",
},
]
`;
exports[`ReactThreeTestRenderer Core toTree() handles complicated tree of fragments 1`] = `
Array [
Object {
"children": Array [
Object {
"children": Array [],
"props": Object {
"args": Array [
0,
0,
0,
],
},
"type": "color",
},
],
"props": Object {
"args": Array [],
},
"type": "group",
},
Object {
"children": Array [
Object {
"children": Array [],
"props": Object {
"args": Array [
0,
0,
255,
],
},
"type": "color",
},
],
"props": Object {
"args": Array [],
},
"type": "group",
},
Object {
"children": Array [
Object {
"children": Array [],
"props": Object {
"args": Array [
255,
0,
0,
],
},
"type": "color",
},
],
"props": Object {
"args": Array [],
},
"type": "group",
},
]
`;
exports[`ReactThreeTestRenderer Core updates children 1`] = `
Array [
Object {
"children": Array [
Object {
"children": Array [
Object {
"children": Array [],
"props": Object {
"args": Array [
2,
2,
],
},
"type": "boxGeometry",
},
Object {
"children": Array [],
"props": Object {
"args": Array [],
},
"type": "meshBasicMaterial",
},
],
"props": Object {
"args": Array [],
"position-z": 12,
},
"type": "mesh",
},
Object {
"children": Array [
Object {
"children": Array [],
"props": Object {
"args": Array [
4,
4,
],
},
"type": "boxGeometry",
},
Object {
"children": Array [],
"props": Object {
"args": Array [],
},
"type": "meshBasicMaterial",
},
],
"props": Object {
"args": Array [],
"position-y": 12,
},
"type": "mesh",
},
Object {
"children": Array [
Object {
"children": Array [],
"props": Object {
"args": Array [
6,
6,
],
},
"type": "boxGeometry",
},
Object {
"children": Array [],
"props": Object {
"args": Array [],
},
"type": "meshBasicMaterial",
},
],
"props": Object {
"args": Array [],
"position-x": 12,
},
"type": "mesh",
},
],
"props": Object {
"args": Array [],
},
"type": "group",
},
]
`;
exports[`ReactThreeTestRenderer Core updates children 2`] = `
Array [
Object {
"children": Array [
Object {
"children": Array [
Object {
"children": Array [],
"props": Object {
"args": Array [
6,
6,
],
},
"type": "boxGeometry",
},
Object {
"children": Array [],
"props": Object {
"args": Array [],
},
"type": "meshBasicMaterial",
},
],
"props": Object {
"args": Array [],
"rotation-x": 1,
},
"type": "mesh",
},
Object {
"children": Array [
Object {
"children": Array [],
"props": Object {
"args": Array [
4,
4,
],
},
"type": "boxGeometry",
},
Object {
"children": Array [],
"props": Object {
"args": Array [],
},
"type": "meshBasicMaterial",
},
],
"props": Object {
"args": Array [],
"position-y": 12,
},
"type": "mesh",
},
Object {
"children": Array [
Object {
"children": Array [],
"props": Object {
"args": Array [],
},
"type": "meshBasicMaterial",
},
Object {
"children": Array [],
"props": Object {
"args": Array [
2,
2,
],
},
"type": "boxGeometry",
},
],
"props": Object {
"args": Array [],
"position-x": 12,
},
"type": "mesh",
},
],
"props": Object {
"args": Array [],
},
"type": "group",
},
]
`;
|
6,823 | 0 | petrpan-code/pmndrs/jotai/tests | petrpan-code/pmndrs/jotai/tests/babel/plugin-debug-label.test.ts | import { transformSync } from '@babel/core'
import { expect, it } from 'vitest'
import plugin from 'jotai/babel/plugin-debug-label'
const transform = (
code: string,
filename?: string,
customAtomNames?: string[],
) =>
transformSync(code, {
babelrc: false,
configFile: false,
filename,
plugins: [[plugin, { customAtomNames }]],
})?.code
it('Should add a debugLabel to an atom', () => {
expect(transform(`const countAtom = atom(0);`)).toMatchInlineSnapshot(`
"const countAtom = atom(0);
countAtom.debugLabel = \\"countAtom\\";"
`)
})
it('Should handle a atom from a default export', () => {
expect(transform(`const countAtom = jotai.atom(0);`)).toMatchInlineSnapshot(`
"const countAtom = jotai.atom(0);
countAtom.debugLabel = \\"countAtom\\";"
`)
})
it('Should handle a atom being exported', () => {
expect(transform(`export const countAtom = atom(0);`)).toMatchInlineSnapshot(`
"export const countAtom = atom(0);
countAtom.debugLabel = \\"countAtom\\";"
`)
})
it('Should handle a default exported atom', () => {
expect(transform(`export default atom(0);`, 'countAtom.ts'))
.toMatchInlineSnapshot(`
"const countAtom = atom(0);
countAtom.debugLabel = \\"countAtom\\";
export default countAtom;"
`)
})
it('Should handle a default exported atom in a barrel file', () => {
expect(transform(`export default atom(0);`, 'atoms/index.ts'))
.toMatchInlineSnapshot(`
"const atoms = atom(0);
atoms.debugLabel = \\"atoms\\";
export default atoms;"
`)
})
it('Should handle all types of exports', () => {
expect(
transform(
`
export const countAtom = atom(0);
export default atom(0);
`,
'atoms/index.ts',
),
).toMatchInlineSnapshot(`
"export const countAtom = atom(0);
countAtom.debugLabel = \\"countAtom\\";
const atoms = atom(0);
atoms.debugLabel = \\"atoms\\";
export default atoms;"
`)
})
it('Should handle all atom types', () => {
expect(
transform(
`
export const countAtom = atom(0);
const myFamily = atomFamily((param) => atom(param));
const countAtomWithDefault = atomWithDefault((get) => get(countAtom) * 2);
const observableAtom = atomWithObservable(() => {});
const reducerAtom = atomWithReducer(0, () => {});
const resetAtom = atomWithReset(0);
const storageAtom = atomWithStorage('count', 1);
const freezedAtom = freezeAtom(atom({ count: 0 }));
const loadedAtom = loadable(countAtom);
const selectedValueAtom = selectAtom(atom({ a: 0, b: 'othervalue' }), (v) => v.a);
const splittedAtom = splitAtom(atom([]));
const unwrappedAtom = unwrap(asyncArrayAtom, () => []);
const someatomWithSubscription = atomWithSubscription(() => {});
const someAtomWithStore = atomWithStore(() => {});
const someAtomWithHash = atomWithHash('', '');
const someAtomWithLocation = atomWithLocation();
const someFocusAtom = focusAtom(someAtom, () => {});
const someAtomWithValidate = atomWithValidate('', {});
const someValidateAtoms = validateAtoms({}, () => {});
const someAtomWithCache = atomWithCache(async () => {});
const someAtomWithRecoilValue = atomWithRecoilValue({});
`,
'atoms/index.ts',
),
).toMatchInlineSnapshot(`
"export const countAtom = atom(0);
countAtom.debugLabel = \\"countAtom\\";
const myFamily = atomFamily(param => atom(param));
myFamily.debugLabel = \\"myFamily\\";
const countAtomWithDefault = atomWithDefault(get => get(countAtom) * 2);
countAtomWithDefault.debugLabel = \\"countAtomWithDefault\\";
const observableAtom = atomWithObservable(() => {});
observableAtom.debugLabel = \\"observableAtom\\";
const reducerAtom = atomWithReducer(0, () => {});
reducerAtom.debugLabel = \\"reducerAtom\\";
const resetAtom = atomWithReset(0);
resetAtom.debugLabel = \\"resetAtom\\";
const storageAtom = atomWithStorage('count', 1);
storageAtom.debugLabel = \\"storageAtom\\";
const freezedAtom = freezeAtom(atom({
count: 0
}));
freezedAtom.debugLabel = \\"freezedAtom\\";
const loadedAtom = loadable(countAtom);
loadedAtom.debugLabel = \\"loadedAtom\\";
const selectedValueAtom = selectAtom(atom({
a: 0,
b: 'othervalue'
}), v => v.a);
selectedValueAtom.debugLabel = \\"selectedValueAtom\\";
const splittedAtom = splitAtom(atom([]));
splittedAtom.debugLabel = \\"splittedAtom\\";
const unwrappedAtom = unwrap(asyncArrayAtom, () => []);
unwrappedAtom.debugLabel = \\"unwrappedAtom\\";
const someatomWithSubscription = atomWithSubscription(() => {});
someatomWithSubscription.debugLabel = \\"someatomWithSubscription\\";
const someAtomWithStore = atomWithStore(() => {});
someAtomWithStore.debugLabel = \\"someAtomWithStore\\";
const someAtomWithHash = atomWithHash('', '');
someAtomWithHash.debugLabel = \\"someAtomWithHash\\";
const someAtomWithLocation = atomWithLocation();
someAtomWithLocation.debugLabel = \\"someAtomWithLocation\\";
const someFocusAtom = focusAtom(someAtom, () => {});
someFocusAtom.debugLabel = \\"someFocusAtom\\";
const someAtomWithValidate = atomWithValidate('', {});
someAtomWithValidate.debugLabel = \\"someAtomWithValidate\\";
const someValidateAtoms = validateAtoms({}, () => {});
someValidateAtoms.debugLabel = \\"someValidateAtoms\\";
const someAtomWithCache = atomWithCache(async () => {});
someAtomWithCache.debugLabel = \\"someAtomWithCache\\";
const someAtomWithRecoilValue = atomWithRecoilValue({});
someAtomWithRecoilValue.debugLabel = \\"someAtomWithRecoilValue\\";"
`)
})
it('Handles custom atom names a debugLabel to an atom', () => {
expect(
transform(`const mySpecialThing = myCustomAtom(0);`, undefined, [
'myCustomAtom',
]),
).toMatchInlineSnapshot(`
"const mySpecialThing = myCustomAtom(0);
mySpecialThing.debugLabel = \\"mySpecialThing\\";"
`)
})
|
6,824 | 0 | petrpan-code/pmndrs/jotai/tests | petrpan-code/pmndrs/jotai/tests/babel/plugin-react-refresh.test.ts | import { transformSync } from '@babel/core'
import { expect, it } from 'vitest'
import plugin from 'jotai/babel/plugin-react-refresh'
const transform = (
code: string,
filename?: string,
customAtomNames?: string[],
) =>
transformSync(code, {
babelrc: false,
configFile: false,
filename,
root: '.',
plugins: [[plugin, { customAtomNames }]],
})?.code
it('Should add a cache for a single atom', () => {
expect(transform(`const countAtom = atom(0);`, '/src/atoms/index.ts'))
.toMatchInlineSnapshot(`
"globalThis.jotaiAtomCache = globalThis.jotaiAtomCache || {
cache: new Map(),
get(name, inst) {
if (this.cache.has(name)) {
return this.cache.get(name);
}
this.cache.set(name, inst);
return inst;
}
};
const countAtom = globalThis.jotaiAtomCache.get(\\"/src/atoms/index.ts/countAtom\\", atom(0));"
`)
})
it('Should add a cache for multiple atoms', () => {
expect(
transform(
`
const countAtom = atom(0);
const doubleAtom = atom((get) => get(countAtom) * 2);
`,
'/src/atoms/index.ts',
),
).toMatchInlineSnapshot(`
"globalThis.jotaiAtomCache = globalThis.jotaiAtomCache || {
cache: new Map(),
get(name, inst) {
if (this.cache.has(name)) {
return this.cache.get(name);
}
this.cache.set(name, inst);
return inst;
}
};
const countAtom = globalThis.jotaiAtomCache.get(\\"/src/atoms/index.ts/countAtom\\", atom(0));
const doubleAtom = globalThis.jotaiAtomCache.get(\\"/src/atoms/index.ts/doubleAtom\\", atom(get => get(countAtom) * 2));"
`)
})
it('Should add a cache for multiple exported atoms', () => {
expect(
transform(
`
export const countAtom = atom(0);
export const doubleAtom = atom((get) => get(countAtom) * 2);
`,
'/src/atoms/index.ts',
),
).toMatchInlineSnapshot(`
"globalThis.jotaiAtomCache = globalThis.jotaiAtomCache || {
cache: new Map(),
get(name, inst) {
if (this.cache.has(name)) {
return this.cache.get(name);
}
this.cache.set(name, inst);
return inst;
}
};
export const countAtom = globalThis.jotaiAtomCache.get(\\"/src/atoms/index.ts/countAtom\\", atom(0));
export const doubleAtom = globalThis.jotaiAtomCache.get(\\"/src/atoms/index.ts/doubleAtom\\", atom(get => get(countAtom) * 2));"
`)
})
it('Should add a cache for a default exported atom', () => {
expect(transform(`export default atom(0);`, '/src/atoms/index.ts'))
.toMatchInlineSnapshot(`
"globalThis.jotaiAtomCache = globalThis.jotaiAtomCache || {
cache: new Map(),
get(name, inst) {
if (this.cache.has(name)) {
return this.cache.get(name);
}
this.cache.set(name, inst);
return inst;
}
};
export default globalThis.jotaiAtomCache.get(\\"/src/atoms/index.ts/defaultExport\\", atom(0));"
`)
})
it('Should add a cache for mixed exports of atoms', () => {
expect(
transform(
`
export const countAtom = atom(0);
export default atom((get) => get(countAtom) * 2);
`,
'/src/atoms/index.ts',
),
).toMatchInlineSnapshot(`
"globalThis.jotaiAtomCache = globalThis.jotaiAtomCache || {
cache: new Map(),
get(name, inst) {
if (this.cache.has(name)) {
return this.cache.get(name);
}
this.cache.set(name, inst);
return inst;
}
};
export const countAtom = globalThis.jotaiAtomCache.get(\\"/src/atoms/index.ts/countAtom\\", atom(0));
export default globalThis.jotaiAtomCache.get(\\"/src/atoms/index.ts/defaultExport\\", atom(get => get(countAtom) * 2));"
`)
})
it('Should fail if no filename is available', () => {
expect(() => transform(`const countAtom = atom(0);`)).toThrow(
'Filename must be available',
)
})
it('Should handle atoms returned from functions (#891)', () => {
expect(
transform(
`function createAtom(label) {
const anAtom = atom(0);
anAtom.debugLabel = label;
return anAtom;
}
const countAtom = atom(0);
const countAtom2 = createAtom("countAtom2");
const countAtom3 = createAtom("countAtom3");`,
'/src/atoms/index.ts',
),
).toMatchInlineSnapshot(`
"globalThis.jotaiAtomCache = globalThis.jotaiAtomCache || {
cache: new Map(),
get(name, inst) {
if (this.cache.has(name)) {
return this.cache.get(name);
}
this.cache.set(name, inst);
return inst;
}
};
function createAtom(label) {
const anAtom = atom(0);
anAtom.debugLabel = label;
return anAtom;
}
const countAtom = globalThis.jotaiAtomCache.get(\\"/src/atoms/index.ts/countAtom\\", atom(0));
const countAtom2 = createAtom(\\"countAtom2\\");
const countAtom3 = createAtom(\\"countAtom3\\");"
`)
})
it('Should handle custom atom names', () => {
expect(
transform(
`const mySpecialThing = myCustomAtom(0);`,
'/src/atoms/index.ts',
['myCustomAtom'],
),
).toMatchInlineSnapshot(`
"globalThis.jotaiAtomCache = globalThis.jotaiAtomCache || {
cache: new Map(),
get(name, inst) {
if (this.cache.has(name)) {
return this.cache.get(name);
}
this.cache.set(name, inst);
return inst;
}
};
const mySpecialThing = globalThis.jotaiAtomCache.get(\\"/src/atoms/index.ts/mySpecialThing\\", myCustomAtom(0));"
`)
})
|
6,825 | 0 | petrpan-code/pmndrs/jotai/tests | petrpan-code/pmndrs/jotai/tests/babel/preset.test.ts | import { transformSync } from '@babel/core'
import { expect, it } from 'vitest'
import preset from 'jotai/babel/preset'
const transform = (
code: string,
filename?: string,
customAtomNames?: string[],
) =>
transformSync(code, {
babelrc: false,
configFile: false,
filename,
presets: [[preset, { customAtomNames }]],
})?.code
it('Should add a debugLabel and cache to an atom', () => {
expect(transform(`const countAtom = atom(0);`, '/src/atoms.ts'))
.toMatchInlineSnapshot(`
"globalThis.jotaiAtomCache = globalThis.jotaiAtomCache || {
cache: new Map(),
get(name, inst) {
if (this.cache.has(name)) {
return this.cache.get(name);
}
this.cache.set(name, inst);
return inst;
}
};
const countAtom = globalThis.jotaiAtomCache.get(\\"/src/atoms.ts/countAtom\\", atom(0));
countAtom.debugLabel = \\"countAtom\\";"
`)
})
it('Should add a debugLabel and cache to multiple atoms', () => {
expect(
transform(
`
const countAtom = atom(0);
const doubleAtom = atom((get) => get(countAtom) * 2);`,
'/src/atoms.ts',
),
).toMatchInlineSnapshot(`
"globalThis.jotaiAtomCache = globalThis.jotaiAtomCache || {
cache: new Map(),
get(name, inst) {
if (this.cache.has(name)) {
return this.cache.get(name);
}
this.cache.set(name, inst);
return inst;
}
};
const countAtom = globalThis.jotaiAtomCache.get(\\"/src/atoms.ts/countAtom\\", atom(0));
countAtom.debugLabel = \\"countAtom\\";
const doubleAtom = globalThis.jotaiAtomCache.get(\\"/src/atoms.ts/doubleAtom\\", atom(get => get(countAtom) * 2));
doubleAtom.debugLabel = \\"doubleAtom\\";"
`)
})
it('Should add a cache and debugLabel for multiple exported atoms', () => {
expect(
transform(
`
export const countAtom = atom(0);
export const doubleAtom = atom((get) => get(countAtom) * 2);
`,
'/src/atoms/index.ts',
),
).toMatchInlineSnapshot(`
"globalThis.jotaiAtomCache = globalThis.jotaiAtomCache || {
cache: new Map(),
get(name, inst) {
if (this.cache.has(name)) {
return this.cache.get(name);
}
this.cache.set(name, inst);
return inst;
}
};
export const countAtom = globalThis.jotaiAtomCache.get(\\"/src/atoms/index.ts/countAtom\\", atom(0));
countAtom.debugLabel = \\"countAtom\\";
export const doubleAtom = globalThis.jotaiAtomCache.get(\\"/src/atoms/index.ts/doubleAtom\\", atom(get => get(countAtom) * 2));
doubleAtom.debugLabel = \\"doubleAtom\\";"
`)
})
it('Should add a cache and debugLabel for a default exported atom', () => {
expect(transform(`export default atom(0);`, '/src/atoms/index.ts'))
.toMatchInlineSnapshot(`
"globalThis.jotaiAtomCache = globalThis.jotaiAtomCache || {
cache: new Map(),
get(name, inst) {
if (this.cache.has(name)) {
return this.cache.get(name);
}
this.cache.set(name, inst);
return inst;
}
};
const atoms = globalThis.jotaiAtomCache.get(\\"/src/atoms/index.ts/atoms\\", atom(0));
atoms.debugLabel = \\"atoms\\";
export default atoms;"
`)
})
it('Should add a cache and debugLabel for mixed exports of atoms', () => {
expect(
transform(
`
export const countAtom = atom(0);
export default atom((get) => get(countAtom) * 2);
`,
'/src/atoms/index.ts',
),
).toMatchInlineSnapshot(`
"globalThis.jotaiAtomCache = globalThis.jotaiAtomCache || {
cache: new Map(),
get(name, inst) {
if (this.cache.has(name)) {
return this.cache.get(name);
}
this.cache.set(name, inst);
return inst;
}
};
export const countAtom = globalThis.jotaiAtomCache.get(\\"/src/atoms/index.ts/countAtom\\", atom(0));
countAtom.debugLabel = \\"countAtom\\";
const atoms = globalThis.jotaiAtomCache.get(\\"/src/atoms/index.ts/atoms\\", atom(get => get(countAtom) * 2));
atoms.debugLabel = \\"atoms\\";
export default atoms;"
`)
})
it('Should fail if no filename is available', () => {
expect(() => transform(`const countAtom = atom(0);`)).toThrow(
'Filename must be available',
)
})
it('Should handle custom atom names', () => {
expect(
transform(`const mySpecialThing = myCustomAtom(0);`, '/src/atoms.ts', [
'myCustomAtom',
]),
).toMatchInlineSnapshot(`
"globalThis.jotaiAtomCache = globalThis.jotaiAtomCache || {
cache: new Map(),
get(name, inst) {
if (this.cache.has(name)) {
return this.cache.get(name);
}
this.cache.set(name, inst);
return inst;
}
};
const mySpecialThing = globalThis.jotaiAtomCache.get(\\"/src/atoms.ts/mySpecialThing\\", myCustomAtom(0));
mySpecialThing.debugLabel = \\"mySpecialThing\\";"
`)
})
|
6,826 | 0 | petrpan-code/pmndrs/jotai/tests | petrpan-code/pmndrs/jotai/tests/react/abortable.test.tsx | import { StrictMode, Suspense, useState } from 'react'
import { render, waitFor } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import { describe, expect, it } from 'vitest'
import { useAtomValue, useSetAtom } from 'jotai/react'
import { atom } from 'jotai/vanilla'
describe('abortable atom test', () => {
it('can abort with signal.aborted', async () => {
const countAtom = atom(0)
let abortedCount = 0
const resolve: (() => void)[] = []
const derivedAtom = atom(async (get, { signal }) => {
const count = get(countAtom)
await new Promise<void>((r) => resolve.push(r))
if (signal.aborted) {
++abortedCount
}
return count
})
const Component = () => {
const count = useAtomValue(derivedAtom)
return <div>count: {count}</div>
}
const Controls = () => {
const setCount = useSetAtom(countAtom)
return (
<>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Component />
<Controls />
</Suspense>
</StrictMode>,
)
await findByText('loading')
resolve.splice(0).forEach((fn) => fn())
await findByText('count: 0')
expect(abortedCount).toBe(0)
await userEvent.click(getByText('button'))
await userEvent.click(getByText('button'))
resolve.splice(0).forEach((fn) => fn())
await findByText('count: 2')
expect(abortedCount).toBe(1)
await userEvent.click(getByText('button'))
resolve.splice(0).forEach((fn) => fn())
await findByText('count: 3')
expect(abortedCount).toBe(1)
})
it('can abort with event listener', async () => {
const countAtom = atom(0)
let abortedCount = 0
const resolve: (() => void)[] = []
const derivedAtom = atom(async (get, { signal }) => {
const count = get(countAtom)
const callback = () => {
++abortedCount
}
signal.addEventListener('abort', callback)
await new Promise<void>((r) => resolve.push(r))
signal.removeEventListener('abort', callback)
return count
})
const Component = () => {
const count = useAtomValue(derivedAtom)
return <div>count: {count}</div>
}
const Controls = () => {
const setCount = useSetAtom(countAtom)
return (
<>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Component />
<Controls />
</Suspense>
</StrictMode>,
)
await findByText('loading')
resolve.splice(0).forEach((fn) => fn())
await findByText('count: 0')
expect(abortedCount).toBe(0)
await userEvent.click(getByText('button'))
await userEvent.click(getByText('button'))
resolve.splice(0).forEach((fn) => fn())
await findByText('count: 2')
expect(abortedCount).toBe(1)
await userEvent.click(getByText('button'))
resolve.splice(0).forEach((fn) => fn())
await findByText('count: 3')
expect(abortedCount).toBe(1)
})
it('can abort on unmount', async () => {
const countAtom = atom(0)
let abortedCount = 0
const resolve: (() => void)[] = []
const derivedAtom = atom(async (get, { signal }) => {
const count = get(countAtom)
await new Promise<void>((r) => resolve.push(r))
if (signal.aborted) {
++abortedCount
}
return count
})
const Component = () => {
const count = useAtomValue(derivedAtom)
return <div>count: {count}</div>
}
const Parent = () => {
const setCount = useSetAtom(countAtom)
const [show, setShow] = useState(true)
return (
<>
{show ? <Component /> : 'hidden'}
<button onClick={() => setCount((c) => c + 1)}>button</button>
<button onClick={() => setShow((x) => !x)}>toggle</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Parent />
</Suspense>
</StrictMode>,
)
await findByText('loading')
resolve.splice(0).forEach((fn) => fn())
await findByText('count: 0')
expect(abortedCount).toBe(0)
await userEvent.click(getByText('button'))
await userEvent.click(getByText('toggle'))
await findByText('hidden')
resolve.splice(0).forEach((fn) => fn())
await waitFor(() => expect(abortedCount).toBe(1))
})
it('throws aborted error (like fetch)', async () => {
const countAtom = atom(0)
const resolve: (() => void)[] = []
const derivedAtom = atom(async (get, { signal }) => {
const count = get(countAtom)
await new Promise<void>((r) => resolve.push(r))
if (signal.aborted) {
throw new Error('aborted')
}
return count
})
const Component = () => {
const count = useAtomValue(derivedAtom)
return <div>count: {count}</div>
}
const Controls = () => {
const setCount = useSetAtom(countAtom)
return (
<>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Component />
<Controls />
</Suspense>
</StrictMode>,
)
await findByText('loading')
resolve.splice(0).forEach((fn) => fn())
await findByText('count: 0')
await userEvent.click(getByText('button'))
await userEvent.click(getByText('button'))
resolve.splice(0).forEach((fn) => fn())
await findByText('count: 2')
await userEvent.click(getByText('button'))
resolve.splice(0).forEach((fn) => fn())
await findByText('count: 3')
})
})
|
6,827 | 0 | petrpan-code/pmndrs/jotai/tests | petrpan-code/pmndrs/jotai/tests/react/async.test.tsx | import { StrictMode, Suspense, useEffect, useRef } from 'react'
import { act, fireEvent, render, waitFor } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import { expect, it } from 'vitest'
import { useAtom } from 'jotai/react'
import { atom } from 'jotai/vanilla'
import type { Atom } from 'jotai/vanilla'
const useCommitCount = () => {
const commitCountRef = useRef(1)
useEffect(() => {
commitCountRef.current += 1
})
return commitCountRef.current
}
it('does not show async stale result', async () => {
const countAtom = atom(0)
let resolve2 = () => {}
const asyncCountAtom = atom(async (get) => {
await new Promise<void>((r) => (resolve2 = r))
return get(countAtom)
})
const committed: number[] = []
let resolve1 = () => {}
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
const onClick = async () => {
setCount((c) => c + 1)
await new Promise<void>((r) => (resolve1 = r))
setCount((c) => c + 1)
}
return (
<>
<div>count: {count}</div>
<button onClick={onClick}>button</button>
</>
)
}
const DelayedCounter = () => {
const [delayedCount] = useAtom(asyncCountAtom)
useEffect(() => {
committed.push(delayedCount)
})
return <div>delayedCount: {delayedCount}</div>
}
const { getByText, findByText } = render(
<>
<Counter />
<Suspense fallback="loading">
<DelayedCounter />
</Suspense>
</>,
)
await findByText('loading')
resolve1()
resolve2()
await waitFor(() => {
getByText('count: 0')
getByText('delayedCount: 0')
})
expect(committed).toEqual([0])
await userEvent.click(getByText('button'))
await findByText('loading')
resolve1()
resolve2()
await waitFor(() => {
getByText('count: 2')
getByText('delayedCount: 2')
})
expect(committed).toEqual([0, 2])
})
it('does not show async stale result on derived atom', async () => {
const countAtom = atom(0)
let resolve = () => {}
const asyncAlwaysNullAtom = atom(async (get) => {
get(countAtom)
await new Promise<void>((r) => (resolve = r))
return null
})
const derivedAtom = atom((get) => get(asyncAlwaysNullAtom))
const DisplayAsyncValue = () => {
const [asyncValue] = useAtom(asyncAlwaysNullAtom)
return <div>async value: {JSON.stringify(asyncValue)}</div>
}
const DisplayDerivedValue = () => {
const [derivedValue] = useAtom(derivedAtom)
return <div>derived value: {JSON.stringify(derivedValue)}</div>
}
const Test = () => {
const [count, setCount] = useAtom(countAtom)
return (
<div>
<div>count: {count}</div>
<Suspense fallback={<div>loading async value</div>}>
<DisplayAsyncValue />
</Suspense>
<Suspense fallback={<div>loading derived value</div>}>
<DisplayDerivedValue />
</Suspense>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</div>
)
}
const { getByText, queryByText } = render(
<StrictMode>
<Test />
</StrictMode>,
)
await waitFor(() => {
getByText('count: 0')
getByText('loading async value')
getByText('loading derived value')
})
resolve()
await waitFor(() => {
expect(queryByText('loading async value')).toBeNull()
expect(queryByText('loading derived value')).toBeNull()
})
await waitFor(() => {
getByText('async value: null')
getByText('derived value: null')
})
await userEvent.click(getByText('button'))
await waitFor(() => {
getByText('count: 1')
getByText('loading async value')
getByText('loading derived value')
})
resolve()
await waitFor(() => {
expect(queryByText('loading async value')).toBeNull()
expect(queryByText('loading derived value')).toBeNull()
})
await waitFor(() => {
getByText('async value: null')
getByText('derived value: null')
})
})
it('works with async get with extra deps', async () => {
const countAtom = atom(0)
const anotherAtom = atom(-1)
let resolve = () => {}
const asyncCountAtom = atom(async (get) => {
get(anotherAtom)
await new Promise<void>((r) => (resolve = r))
return get(countAtom)
})
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const DelayedCounter = () => {
const [delayedCount] = useAtom(asyncCountAtom)
return <div>delayedCount: {delayedCount}</div>
}
const { getByText, findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
<DelayedCounter />
</Suspense>
</StrictMode>,
)
await findByText('loading')
resolve()
await waitFor(() => {
getByText('count: 0')
getByText('delayedCount: 0')
})
await userEvent.click(getByText('button'))
await findByText('loading')
resolve()
await waitFor(() => {
getByText('count: 1')
getByText('delayedCount: 1')
})
})
it('reuses promises on initial read', async () => {
let invokeCount = 0
let resolve = () => {}
const asyncAtom = atom(async () => {
invokeCount += 1
await new Promise<void>((r) => (resolve = r))
return 'ready'
})
const Child = () => {
const [str] = useAtom(asyncAtom)
return <div>{str}</div>
}
const { findByText, findAllByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Child />
<Child />
</Suspense>
</StrictMode>,
)
await findByText('loading')
resolve()
await findAllByText('ready')
expect(invokeCount).toBe(1)
})
it('uses multiple async atoms at once', async () => {
const resolve: (() => void)[] = []
const someAtom = atom(async () => {
await new Promise<void>((r) => resolve.push(r))
return 'ready'
})
const someAtom2 = atom(async () => {
await new Promise<void>((r) => resolve.push(r))
return 'ready2'
})
const Component = () => {
const [some] = useAtom(someAtom)
const [some2] = useAtom(someAtom2)
return (
<>
<div>
{some} {some2}
</div>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Component />
</Suspense>
</StrictMode>,
)
await findByText('loading')
await waitFor(() => {
resolve.splice(0).forEach((fn) => fn())
getByText('ready ready2')
})
})
it('uses async atom in the middle of dependency chain', async () => {
const countAtom = atom(0)
let resolve = () => {}
const asyncCountAtom = atom(async (get) => {
await new Promise<void>((r) => (resolve = r))
return get(countAtom)
})
const delayedCountAtom = atom((get) => get(asyncCountAtom))
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
const [delayedCount] = useAtom(delayedCountAtom)
return (
<>
<div>
count: {count}, delayed: {delayedCount}
</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('loading')
resolve()
await findByText('count: 0, delayed: 0')
await userEvent.click(getByText('button'))
await findByText('loading')
resolve()
await findByText('count: 1, delayed: 1')
})
it('updates an async atom in child useEffect on remount without setTimeout', async () => {
const toggleAtom = atom(true)
const countAtom = atom(0)
const asyncCountAtom = atom(
async (get) => get(countAtom),
async (get, set) => set(countAtom, get(countAtom) + 1),
)
const Counter = () => {
const [count, incCount] = useAtom(asyncCountAtom)
useEffect(() => {
incCount()
}, [incCount])
return <div>count: {count}</div>
}
const Parent = () => {
const [toggle, setToggle] = useAtom(toggleAtom)
return (
<>
<button onClick={() => setToggle((x) => !x)}>button</button>
{toggle ? <Counter /> : <div>no child</div>}
</>
)
}
const { getByText, findByText } = render(
<>
<Suspense fallback="loading">
<Parent />
</Suspense>
</>,
)
await findByText('count: 0')
await findByText('count: 1')
await userEvent.click(getByText('button'))
await findByText('no child')
await userEvent.click(getByText('button'))
await findByText('count: 2')
})
it('updates an async atom in child useEffect on remount', async () => {
const toggleAtom = atom(true)
const countAtom = atom(0)
const resolve: (() => void)[] = []
const asyncCountAtom = atom(
async (get) => {
await new Promise<void>((r) => resolve.push(r))
return get(countAtom)
},
async (get, set) => {
await new Promise<void>((r) => resolve.push(r))
set(countAtom, get(countAtom) + 1)
},
)
const Counter = () => {
const [count, incCount] = useAtom(asyncCountAtom)
useEffect(() => {
incCount()
}, [incCount])
return <div>count: {count}</div>
}
const Parent = () => {
const [toggle, setToggle] = useAtom(toggleAtom)
return (
<>
<button onClick={() => setToggle((x) => !x)}>button</button>
{toggle ? <Counter /> : <div>no child</div>}
</>
)
}
const { getByText, findByText } = render(
<>
<Suspense fallback="loading">
<Parent />
</Suspense>
</>,
)
await findByText('loading')
act(() => resolve.splice(0).forEach((fn) => fn()))
await findByText('count: 0')
await act(async () => {
resolve.splice(0).forEach((fn) => fn())
await new Promise((r) => setTimeout(r)) // wait for a tick
resolve.splice(0).forEach((fn) => fn())
})
await findByText('count: 1')
await userEvent.click(getByText('button'))
await findByText('no child')
await userEvent.click(getByText('button'))
await act(async () => {
resolve.splice(0).forEach((fn) => fn())
await new Promise((r) => setTimeout(r)) // wait for a tick
resolve.splice(0).forEach((fn) => fn())
})
await findByText('count: 2')
})
it('async get and useEffect on parent', async () => {
const countAtom = atom(0)
const asyncAtom = atom(async (get) => {
const count = get(countAtom)
if (!count) return 'none'
return 'resolved'
})
const AsyncComponent = () => {
const [text] = useAtom(asyncAtom)
return <div>text: {text}</div>
}
const Parent = () => {
const [count, setCount] = useAtom(countAtom)
useEffect(() => {
setCount((c) => c + 1)
}, [setCount])
return (
<>
<div>count: {count}</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
<AsyncComponent />
</>
)
}
const { getByText, findByText } = render(
<>
<Suspense fallback="loading">
<Parent />
</Suspense>
</>,
)
await findByText('loading')
await waitFor(() => {
getByText('count: 1')
getByText('text: resolved')
})
})
it('async get with another dep and useEffect on parent', async () => {
const countAtom = atom(0)
const derivedAtom = atom((get) => get(countAtom))
const asyncAtom = atom(async (get) => {
const count = get(derivedAtom)
if (!count) return 'none'
return count
})
const AsyncComponent = () => {
const [count] = useAtom(asyncAtom)
return <div>async: {count}</div>
}
const Parent = () => {
const [count, setCount] = useAtom(countAtom)
useEffect(() => {
setCount((c) => c + 1)
}, [setCount])
return (
<>
<div>count: {count}</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
<AsyncComponent />
</>
)
}
const { getByText, findByText } = render(
<>
<Suspense fallback="loading">
<Parent />
</Suspense>
</>,
)
await findByText('loading')
await waitFor(() => {
getByText('count: 1')
getByText('async: 1')
})
await userEvent.click(getByText('button'))
await waitFor(() => {
getByText('count: 2')
getByText('async: 2')
})
})
it('set promise atom value on write (#304)', async () => {
const countAtom = atom(Promise.resolve(0))
let resolve = () => {}
const asyncAtom = atom(null, (get, set, _arg) => {
set(
countAtom,
Promise.resolve(get(countAtom)).then(
(c) => new Promise((r) => (resolve = () => r(c + 1))),
),
)
})
const Counter = () => {
const [count] = useAtom(countAtom)
return <div>count: {count * 1}</div>
}
const Parent = () => {
const [, dispatch] = useAtom(asyncAtom)
return (
<>
<Counter />
<button onClick={dispatch}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Parent />
</Suspense>
</StrictMode>,
)
await findByText('loading')
await findByText('count: 0')
await userEvent.click(getByText('button'))
await findByText('loading')
resolve()
await findByText('count: 1')
})
it('uses async atom double chain (#306)', async () => {
const countAtom = atom(0)
let resolve = () => {}
const asyncCountAtom = atom(async (get) => {
await new Promise<void>((r) => (resolve = r))
return get(countAtom)
})
const delayedCountAtom = atom(async (get) => {
return get(asyncCountAtom)
})
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
const [delayedCount] = useAtom(delayedCountAtom)
return (
<>
<div>
count: {count}, delayed: {delayedCount}
</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('loading')
resolve()
await findByText('count: 0, delayed: 0')
await userEvent.click(getByText('button'))
await findByText('loading')
resolve()
await findByText('count: 1, delayed: 1')
})
it('uses an async atom that depends on another async atom', async () => {
let resolve = () => {}
const asyncAtom = atom(async (get) => {
await new Promise<void>((r) => (resolve = r))
get(anotherAsyncAtom)
return 1
})
const anotherAsyncAtom = atom(async () => {
return 2
})
const Counter = () => {
const [num] = useAtom(asyncAtom)
return <div>num: {num}</div>
}
const { findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('loading')
resolve()
await findByText('num: 1')
})
it('a derived atom from a newly created async atom (#351)', async () => {
const countAtom = atom(1)
const atomCache = new Map<number, Atom<Promise<number>>>()
const getAsyncAtom = (n: number) => {
if (!atomCache.has(n)) {
atomCache.set(
n,
atom(async () => {
return n + 10
}),
)
}
return atomCache.get(n) as Atom<Promise<number>>
}
const derivedAtom = atom((get) => get(getAsyncAtom(get(countAtom))))
const Counter = () => {
const [, setCount] = useAtom(countAtom)
const [derived] = useAtom(derivedAtom)
return (
<>
<div>
derived: {derived}, commits: {useCommitCount()}
</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<>
<Suspense fallback="loading">
<Counter />
</Suspense>
</>,
)
await findByText('loading')
await findByText('derived: 11, commits: 1')
fireEvent.click(getByText('button'))
await findByText('loading')
await findByText('derived: 12, commits: 2')
fireEvent.click(getByText('button'))
await findByText('loading')
await findByText('derived: 13, commits: 3')
})
it('Handles synchronously invoked async set (#375)', async () => {
const loadingAtom = atom(false)
const documentAtom = atom<string | undefined>(undefined)
let resolve = () => {}
const loadDocumentAtom = atom(null, (_get, set) => {
const fetch = async () => {
set(loadingAtom, true)
const response = await new Promise<string>(
(r) => (resolve = () => r('great document')),
)
set(documentAtom, response)
set(loadingAtom, false)
}
fetch()
})
const ListDocuments = () => {
const [loading] = useAtom(loadingAtom)
const [document] = useAtom(documentAtom)
const [, loadDocument] = useAtom(loadDocumentAtom)
useEffect(() => {
loadDocument()
}, [loadDocument])
return (
<>
{loading && <div>loading</div>}
{!loading && <div>{document}</div>}
</>
)
}
const { findByText } = render(
<StrictMode>
<ListDocuments />
</StrictMode>,
)
await findByText('loading')
resolve()
await findByText('great document')
})
it('async write self atom', async () => {
let resolve = () => {}
const countAtom = atom(0, async (get, set, _arg) => {
set(countAtom, get(countAtom) + 1)
await new Promise<void>((r) => (resolve = r))
set(countAtom, -1)
})
const Counter = () => {
const [count, inc] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={inc}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
await userEvent.click(getByText('button'))
resolve()
await findByText('count: -1')
})
it('non suspense async write self atom with setTimeout (#389)', async () => {
const countAtom = atom(0, (get, set, _arg) => {
set(countAtom, get(countAtom) + 1)
setTimeout(() => set(countAtom, -1))
})
const Counter = () => {
const [count, inc] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={inc}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('button'))
await findByText('count: 1')
await findByText('count: -1')
})
it('should override promise as atom value (#430)', async () => {
const countAtom = atom(new Promise<number>(() => {}))
const setCountAtom = atom(null, (_get, set, arg: number) => {
set(countAtom, Promise.resolve(arg))
})
const Counter = () => {
const [count] = useAtom(countAtom)
return <div>count: {count * 1}</div>
}
const Control = () => {
const [, setCount] = useAtom(setCountAtom)
return <button onClick={() => setCount(1)}>button</button>
}
const { getByText, findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
<Control />
</StrictMode>,
)
await findByText('loading')
await userEvent.click(getByText('button'))
await findByText('count: 1')
})
it('combine two promise atom values (#442)', async () => {
const count1Atom = atom(new Promise<number>(() => {}))
const count2Atom = atom(new Promise<number>(() => {}))
const derivedAtom = atom(
async (get) => (await get(count1Atom)) + (await get(count2Atom)),
)
const initAtom = atom(null, (_get, set) => {
setTimeout(() => set(count1Atom, Promise.resolve(1)))
setTimeout(() => set(count2Atom, Promise.resolve(2)))
})
initAtom.onMount = (init) => {
init()
}
const Counter = () => {
const [count] = useAtom(derivedAtom)
return <div>count: {count}</div>
}
const Control = () => {
useAtom(initAtom)
return null
}
const { findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
<Control />
</StrictMode>,
)
await findByText('loading')
await findByText('count: 3')
})
it('set two promise atoms at once', async () => {
const count1Atom = atom(new Promise<number>(() => {}))
const count2Atom = atom(new Promise<number>(() => {}))
const derivedAtom = atom(
async (get) => (await get(count1Atom)) + (await get(count2Atom)),
)
const setCountsAtom = atom(null, (_get, set) => {
set(count1Atom, Promise.resolve(1))
set(count2Atom, Promise.resolve(2))
})
const Counter = () => {
const [count] = useAtom(derivedAtom)
return <div>count: {count}</div>
}
const Control = () => {
const [, setCounts] = useAtom(setCountsAtom)
return <button onClick={() => setCounts()}>button</button>
}
const { getByText, findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
<Control />
</StrictMode>,
)
await findByText('loading')
await userEvent.click(getByText('button'))
await findByText('count: 3')
})
it('async write chain', async () => {
const countAtom = atom(0)
let resolve1 = () => {}
const asyncWriteAtom = atom(null, async (_get, set, _arg) => {
await new Promise<void>((r) => (resolve1 = r))
set(countAtom, 2)
})
let resolve2 = () => {}
const controlAtom = atom(null, async (_get, set, _arg) => {
set(countAtom, 1)
await set(asyncWriteAtom, null)
await new Promise<void>((r) => (resolve2 = r))
set(countAtom, 3)
})
const Counter = () => {
const [count] = useAtom(countAtom)
return <div>count: {count}</div>
}
const Control = () => {
const [, invoke] = useAtom(controlAtom)
return <button onClick={invoke}>button</button>
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
<Control />
</StrictMode>,
)
await findByText('count: 0')
await userEvent.click(getByText('button'))
await findByText('count: 1')
resolve1()
await findByText('count: 2')
resolve2()
await findByText('count: 3')
})
it('async atom double chain without setTimeout (#751)', async () => {
const enabledAtom = atom(false)
let resolve = () => {}
const asyncAtom = atom(async (get) => {
const enabled = get(enabledAtom)
if (!enabled) {
return 'init'
}
await new Promise<void>((r) => (resolve = r))
return 'ready'
})
const derivedAsyncAtom = atom(async (get) => get(asyncAtom))
const anotherAsyncAtom = atom(async (get) => get(derivedAsyncAtom))
const AsyncComponent = () => {
const [text] = useAtom(anotherAsyncAtom)
return <div>async: {text}</div>
}
const Parent = () => {
// Use useAtom to reproduce the issue
const [, setEnabled] = useAtom(enabledAtom)
return (
<>
<Suspense fallback="loading">
<AsyncComponent />
</Suspense>
<button
onClick={() => {
setEnabled(true)
}}
>
button
</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Parent />
</StrictMode>,
)
await findByText('loading')
await findByText('async: init')
await userEvent.click(getByText('button'))
await findByText('loading')
resolve()
await findByText('async: ready')
})
it('async atom double chain with setTimeout', async () => {
const enabledAtom = atom(false)
const resolve: (() => void)[] = []
const asyncAtom = atom(async (get) => {
const enabled = get(enabledAtom)
if (!enabled) {
return 'init'
}
await new Promise<void>((r) => resolve.push(r))
return 'ready'
})
const derivedAsyncAtom = atom(async (get) => {
await new Promise<void>((r) => resolve.push(r))
return get(asyncAtom)
})
const anotherAsyncAtom = atom(async (get) => {
await new Promise<void>((r) => resolve.push(r))
return get(derivedAsyncAtom)
})
const AsyncComponent = () => {
const [text] = useAtom(anotherAsyncAtom)
return <div>async: {text}</div>
}
const Parent = () => {
// Use useAtom to reproduce the issue
const [, setEnabled] = useAtom(enabledAtom)
return (
<>
<Suspense fallback="loading">
<AsyncComponent />
</Suspense>
<button
onClick={() => {
setEnabled(true)
}}
>
button
</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Parent />
</StrictMode>,
)
act(() => resolve.splice(0).forEach((fn) => fn()))
await findByText('loading')
act(() => resolve.splice(0).forEach((fn) => fn()))
await act(() => new Promise((r) => setTimeout(r))) // wait for a tick
act(() => resolve.splice(0).forEach((fn) => fn()))
await findByText('async: init')
await userEvent.click(getByText('button'))
await findByText('loading')
act(() => resolve.splice(0).forEach((fn) => fn()))
await act(() => new Promise((r) => setTimeout(r))) // wait for a tick
act(() => resolve.splice(0).forEach((fn) => fn()))
await findByText('async: ready')
})
it('update unmounted async atom with intermediate atom', async () => {
const enabledAtom = atom(true)
const countAtom = atom(1)
const resolve: (() => void)[] = []
const intermediateAtom = atom((get) => {
const count = get(countAtom)
const enabled = get(enabledAtom)
const tmpAtom = atom(async () => {
if (!enabled) {
return -1
}
await new Promise<void>((r) => resolve.push(r))
return count * 2
})
return tmpAtom
})
const derivedAtom = atom((get) => {
const tmpAtom = get(intermediateAtom)
return get(tmpAtom)
})
const DerivedCounter = () => {
const [derived] = useAtom(derivedAtom)
return <div>derived: {derived}</div>
}
const Control = () => {
const [, setEnabled] = useAtom(enabledAtom)
const [, setCount] = useAtom(countAtom)
return (
<>
<button onClick={() => setCount((c) => c + 1)}>increment count</button>
<button onClick={() => setEnabled((x) => !x)}>toggle enabled</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<DerivedCounter />
</Suspense>
<Control />
</StrictMode>,
)
await findByText('loading')
resolve.splice(0).forEach((fn) => fn())
await findByText('derived: 2')
await userEvent.click(getByText('toggle enabled'))
await userEvent.click(getByText('increment count'))
await findByText('derived: -1')
await userEvent.click(getByText('toggle enabled'))
await findByText('loading')
resolve.splice(0).forEach((fn) => fn())
await findByText('derived: 4')
})
it('multiple derived atoms with dependency chaining and async write (#813)', async () => {
const responseBaseAtom = atom<{ name: string }[] | null>(null)
const response1 = [{ name: 'alpha' }, { name: 'beta' }]
const responseAtom = atom(
(get) => get(responseBaseAtom),
(_get, set) => {
setTimeout(() => set(responseBaseAtom, response1))
},
)
responseAtom.onMount = (init) => {
init()
}
const mapAtom = atom((get) => get(responseAtom))
const itemA = atom((get) => get(mapAtom)?.[0])
const itemB = atom((get) => get(mapAtom)?.[1])
const itemAName = atom((get) => get(itemA)?.name)
const itemBName = atom((get) => get(itemB)?.name)
const App = () => {
const [aName] = useAtom(itemAName)
const [bName] = useAtom(itemBName)
return (
<>
<div>aName: {aName}</div>
<div>bName: {bName}</div>
</>
)
}
const { getByText } = render(
<StrictMode>
<App />
</StrictMode>,
)
await waitFor(() => {
getByText('aName: alpha')
getByText('bName: beta')
})
})
|
6,828 | 0 | petrpan-code/pmndrs/jotai/tests | petrpan-code/pmndrs/jotai/tests/react/async2.test.tsx | import { StrictMode, Suspense } from 'react'
import { fireEvent, render, waitFor } from '@testing-library/react'
import { assert, describe, expect, it } from 'vitest'
import { useAtom, useAtomValue, useSetAtom } from 'jotai/react'
import { atom } from 'jotai/vanilla'
describe('useAtom delay option test', () => {
it('suspend for Promise.resovle without delay option', async () => {
const countAtom = atom(0)
const asyncAtom = atom((get) => {
const count = get(countAtom)
if (count === 0) {
return 0
}
return Promise.resolve(count)
})
const Component = () => {
const count = useAtomValue(asyncAtom)
return <div>count: {count}</div>
}
const Controls = () => {
const setCount = useSetAtom(countAtom)
return (
<>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Component />
<Controls />
</Suspense>
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('button'))
await findByText('loading')
await findByText('count: 1')
})
it('do not suspend for Promise.resovle with delay option', async () => {
const countAtom = atom(0)
const asyncAtom = atom((get) => {
const count = get(countAtom)
if (count === 0) {
return 0
}
return Promise.resolve(count)
})
const Component = () => {
const count = useAtomValue(asyncAtom, { delay: 0 })
return <div>count: {count}</div>
}
const Controls = () => {
const setCount = useSetAtom(countAtom)
return (
<>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Component />
<Controls />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('button'))
await findByText('count: 1')
})
})
describe('atom read function setSelf option test', () => {
it('do not suspend with promise resolving with setSelf', async () => {
const countAtom = atom(0)
let resolve = () => {}
const asyncAtom = atom(async () => {
await new Promise<void>((r) => (resolve = r))
return 'hello'
})
const refreshAtom = atom(0)
const promiseCache = new WeakMap<object, string>()
const derivedAtom = atom(
(get, { setSelf }) => {
get(refreshAtom)
const count = get(countAtom)
const promise = get(asyncAtom)
if (promiseCache.has(promise)) {
return (promiseCache.get(promise) as string) + count
}
promise.then((v) => {
promiseCache.set(promise, v)
setSelf()
})
return 'pending' + count
},
(_get, set) => {
set(refreshAtom, (c) => c + 1)
},
)
const Component = () => {
const text = useAtomValue(derivedAtom)
return <div>text: {text}</div>
}
const Controls = () => {
const setCount = useSetAtom(countAtom)
return (
<>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Component />
<Controls />
</StrictMode>,
)
await findByText('text: pending0')
resolve()
await findByText('text: hello0')
fireEvent.click(getByText('button'))
await findByText('text: hello1')
})
})
describe('timing issue with setSelf', () => {
it('resolves dependencies reliably after a delay (#2192)', async () => {
expect.assertions(1)
const countAtom = atom(0)
let result: number | null = null
const resolve: (() => void)[] = []
const asyncAtom = atom(async (get) => {
const count = get(countAtom)
await new Promise<void>((r) => resolve.push(r))
return count
})
const derivedAtom = atom(
async (get, { setSelf }) => {
get(countAtom)
await Promise.resolve()
const resultCount = await get(asyncAtom)
result = resultCount
if (resultCount === 2) setSelf() // <-- necessary
},
() => {},
)
const derivedSyncAtom = atom((get) => {
get(derivedAtom)
})
const increment = (c: number) => c + 1
function TestComponent() {
useAtom(derivedSyncAtom)
const [count, setCount] = useAtom(countAtom)
const onClick = () => {
setCount(increment)
setCount(increment)
}
return (
<>
count: {count}
<button onClick={onClick}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<TestComponent />
</StrictMode>,
)
await waitFor(() => assert(resolve.length === 1))
resolve[0]!()
// The use of fireEvent is required to reproduce the issue
fireEvent.click(getByText('button'))
await waitFor(() => assert(resolve.length === 3))
resolve[1]!()
resolve[2]!()
await waitFor(() => assert(result === 2))
// The use of fireEvent is required to reproduce the issue
fireEvent.click(getByText('button'))
await waitFor(() => assert(resolve.length === 5))
resolve[3]!()
resolve[4]!()
await findByText('count: 4')
expect(result).toBe(4) // 3
})
})
|
6,829 | 0 | petrpan-code/pmndrs/jotai/tests | petrpan-code/pmndrs/jotai/tests/react/basic.test.tsx | import {
StrictMode,
Suspense,
version as reactVersion,
useEffect,
useMemo,
useRef,
useState,
} from 'react'
import { fireEvent, render, waitFor } from '@testing-library/react'
import { unstable_batchedUpdates } from 'react-dom'
import { expect, it, vi } from 'vitest'
import { useAtom } from 'jotai/react'
import { atom } from 'jotai/vanilla'
import type { PrimitiveAtom } from 'jotai/vanilla'
const IS_REACT18 = /^18\./.test(reactVersion)
const batchedUpdates = (fn: () => void) => {
if (IS_REACT18) {
fn()
} else {
unstable_batchedUpdates(fn)
}
}
const useCommitCount = () => {
const commitCountRef = useRef(1)
useEffect(() => {
commitCountRef.current += 1
})
return commitCountRef.current
}
it('uses a primitive atom', async () => {
const countAtom = atom(0)
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('button'))
await findByText('count: 1')
})
it('uses a read-only derived atom', async () => {
const countAtom = atom(0)
const doubledCountAtom = atom((get) => get(countAtom) * 2)
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
const [doubledCount] = useAtom(doubledCountAtom)
return (
<>
<div>count: {count}</div>
<div>doubledCount: {doubledCount}</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await waitFor(() => {
getByText('count: 0')
getByText('doubledCount: 0')
})
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('count: 1')
getByText('doubledCount: 2')
})
})
it('uses a read-write derived atom', async () => {
const countAtom = atom(0)
const doubledCountAtom = atom(
(get) => get(countAtom) * 2,
(get, set, update: number) => set(countAtom, get(countAtom) + update),
)
const Counter = () => {
const [count] = useAtom(countAtom)
const [doubledCount, increaseCount] = useAtom(doubledCountAtom)
return (
<>
<div>count: {count}</div>
<div>doubledCount: {doubledCount}</div>
<button onClick={() => increaseCount(2)}>button</button>
</>
)
}
const { getByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await waitFor(() => {
getByText('count: 0')
getByText('doubledCount: 0')
})
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('count: 2')
getByText('doubledCount: 4')
})
})
it('uses a write-only derived atom', async () => {
const countAtom = atom(0)
const incrementCountAtom = atom(null, (get, set) =>
set(countAtom, get(countAtom) + 1),
)
const Counter = () => {
const [count] = useAtom(countAtom)
return (
<div>
commits: {useCommitCount()}, count: {count}
</div>
)
}
const Control = () => {
const [, increment] = useAtom(incrementCountAtom)
return (
<>
<div>button commits: {useCommitCount()}</div>
<button onClick={() => increment()}>button</button>
</>
)
}
const { getByText } = render(
<>
<Counter />
<Control />
</>,
)
await waitFor(() => {
getByText('commits: 1, count: 0')
getByText('button commits: 1')
})
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('commits: 2, count: 1')
getByText('button commits: 1')
})
})
it('only re-renders if value has changed', async () => {
const count1Atom = atom(0)
const count2Atom = atom(0)
const productAtom = atom((get) => get(count1Atom) * get(count2Atom))
type Props = { countAtom: typeof count1Atom; name: string }
const Counter = ({ countAtom, name }: Props) => {
const [count, setCount] = useAtom(countAtom)
return (
<>
<div>
commits: {useCommitCount()}, {name}: {count}
</div>
<button onClick={() => setCount((c) => c + 1)}>button-{name}</button>
</>
)
}
const Product = () => {
const [product] = useAtom(productAtom)
return (
<>
<div data-testid="product">
commits: {useCommitCount()}, product: {product}
</div>
</>
)
}
const { getByText } = render(
<>
<Counter countAtom={count1Atom} name="count1" />
<Counter countAtom={count2Atom} name="count2" />
<Product />
</>,
)
await waitFor(() => {
getByText('commits: 1, count1: 0')
getByText('commits: 1, count2: 0')
getByText('commits: 1, product: 0')
})
fireEvent.click(getByText('button-count1'))
await waitFor(() => {
getByText('commits: 2, count1: 1')
getByText('commits: 1, count2: 0')
getByText('commits: 1, product: 0')
})
fireEvent.click(getByText('button-count2'))
await waitFor(() => {
getByText('commits: 2, count1: 1')
getByText('commits: 2, count2: 1')
getByText('commits: 2, product: 1')
})
})
it('re-renders a time delayed derived atom with the same initial value (#947)', async () => {
const aAtom = atom(false)
aAtom.onMount = (set) => {
setTimeout(() => {
set(true)
})
}
const bAtom = atom(1)
bAtom.onMount = (set) => {
set(2)
}
const cAtom = atom((get) => {
if (get(aAtom)) {
return get(bAtom)
}
return 1
})
const App = () => {
const [value] = useAtom(cAtom)
return <>{value}</>
}
const { findByText } = render(
<StrictMode>
<App />
</StrictMode>,
)
await findByText('2')
})
it('works with async get', async () => {
const countAtom = atom(0)
let resolve = () => {}
const asyncCountAtom = atom(async (get) => {
await new Promise<void>((r) => (resolve = r))
return get(countAtom)
})
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
const [delayedCount] = useAtom(asyncCountAtom)
return (
<>
<div>
commits: {useCommitCount()}, count: {count}, delayedCount:{' '}
{delayedCount}
</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<>
<Suspense fallback="loading">
<Counter />
</Suspense>
</>,
)
await findByText('loading')
resolve()
await findByText('commits: 1, count: 0, delayedCount: 0')
fireEvent.click(getByText('button'))
await findByText('loading')
resolve()
await findByText('commits: 2, count: 1, delayedCount: 1')
fireEvent.click(getByText('button'))
await findByText('loading')
resolve()
await findByText('commits: 3, count: 2, delayedCount: 2')
})
it('works with async get without setTimeout', async () => {
const countAtom = atom(0)
const asyncCountAtom = atom(async (get) => {
return get(countAtom)
})
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
const [delayedCount] = useAtom(asyncCountAtom)
return (
<>
<div>
count: {count}, delayedCount: {delayedCount}
</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('loading')
await findByText('count: 0, delayedCount: 0')
fireEvent.click(getByText('button'))
await findByText('count: 1, delayedCount: 1')
fireEvent.click(getByText('button'))
await findByText('count: 2, delayedCount: 2')
})
it('uses atoms with tree dependencies', async () => {
const topAtom = atom(0)
const leftAtom = atom((get) => get(topAtom))
let resolve = () => {}
const rightAtom = atom(
(get) => get(topAtom),
async (get, set, update: (prev: number) => number) => {
await new Promise<void>((r) => (resolve = r))
batchedUpdates(() => {
set(topAtom, update(get(topAtom)))
})
},
)
const Counter = () => {
const [count] = useAtom(leftAtom)
const [, setCount] = useAtom(rightAtom)
return (
<>
<div>
commits: {useCommitCount()}, count: {count}
</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<>
<Counter />
</>,
)
await findByText('commits: 1, count: 0')
fireEvent.click(getByText('button'))
resolve()
await findByText('commits: 2, count: 1')
fireEvent.click(getByText('button'))
resolve()
await findByText('commits: 3, count: 2')
})
it('runs update only once in StrictMode', async () => {
let updateCount = 0
const countAtom = atom(0)
const derivedAtom = atom(
(get) => get(countAtom),
(_get, set, update: number) => {
updateCount += 1
set(countAtom, update)
},
)
const Counter = () => {
const [count, setCount] = useAtom(derivedAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => setCount(count + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
expect(updateCount).toBe(0)
fireEvent.click(getByText('button'))
await findByText('count: 1')
expect(updateCount).toBe(1)
})
it('uses an async write-only atom', async () => {
const countAtom = atom(0)
let resolve = () => {}
const asyncCountAtom = atom(
null,
async (get, set, update: (prev: number) => number) => {
await new Promise<void>((r) => (resolve = r))
set(countAtom, update(get(countAtom)))
},
)
const Counter = () => {
const [count] = useAtom(countAtom)
const [, setCount] = useAtom(asyncCountAtom)
return (
<>
<div>
commits: {useCommitCount()}, count: {count}
</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<>
<Counter />
</>,
)
await findByText('commits: 1, count: 0')
fireEvent.click(getByText('button'))
resolve()
await findByText('commits: 2, count: 1')
})
it('uses a writable atom without read function', async () => {
let resolve = () => {}
const countAtom = atom(1, async (get, set, v: number) => {
await new Promise<void>((r) => (resolve = r))
set(countAtom, get(countAtom) + 10 * v)
})
const Counter = () => {
const [count, addCount10Times] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => addCount10Times(1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 1')
fireEvent.click(getByText('button'))
resolve()
await findByText('count: 11')
})
it('can write an atom value on useEffect', async () => {
const countAtom = atom(0)
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
useEffect(() => {
setCount((c) => c + 1)
}, [setCount])
return <div>count: {count}</div>
}
const { findByText } = render(
<>
<Counter />
</>,
)
await findByText('count: 1')
})
it('can write an atom value on useEffect in children', async () => {
const countAtom = atom(0)
const Child = ({
setCount,
}: {
setCount: (f: (c: number) => number) => void
}) => {
useEffect(() => {
setCount((c) => c + 1)
}, [setCount])
return null
}
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
return (
<div>
count: {count}
<Child setCount={setCount} />
<Child setCount={setCount} />
</div>
)
}
const { findByText } = render(
<>
<Counter />
</>,
)
await findByText('count: 2')
})
it('only invoke read function on use atom', async () => {
const countAtom = atom(0)
let readCount = 0
const doubledCountAtom = atom((get) => {
readCount += 1
return get(countAtom) * 2
})
expect(readCount).toBe(0) // do not invoke on atom()
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
const [doubledCount] = useAtom(doubledCountAtom)
return (
<>
<div>
commits: {useCommitCount()}, count: {count}, readCount: {readCount},
doubled: {doubledCount}
</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<>
<Counter />
</>,
)
await findByText('commits: 1, count: 0, readCount: 1, doubled: 0')
fireEvent.click(getByText('button'))
await findByText('commits: 2, count: 1, readCount: 2, doubled: 2')
})
it('uses a read-write derived atom with two primitive atoms', async () => {
const countAAtom = atom(0)
const countBAtom = atom(0)
const sumAtom = atom(
(get) => get(countAAtom) + get(countBAtom),
(_get, set) => {
set(countAAtom, 0)
set(countBAtom, 0)
},
)
const incBothAtom = atom(null, (get, set) => {
set(countAAtom, get(countAAtom) + 1)
set(countBAtom, get(countBAtom) + 1)
})
const Counter = () => {
const [countA, setCountA] = useAtom(countAAtom)
const [countB, setCountB] = useAtom(countBAtom)
const [sum, reset] = useAtom(sumAtom)
const [, incBoth] = useAtom(incBothAtom)
return (
<>
<div>
countA: {countA}, countB: {countB}, sum: {sum}
</div>
<button onClick={() => setCountA((c) => c + 1)}>incA</button>
<button onClick={() => setCountB((c) => c + 1)}>incB</button>
<button onClick={reset}>reset</button>
<button onClick={incBoth}>incBoth</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('countA: 0, countB: 0, sum: 0')
fireEvent.click(getByText('incA'))
await findByText('countA: 1, countB: 0, sum: 1')
fireEvent.click(getByText('incB'))
await findByText('countA: 1, countB: 1, sum: 2')
fireEvent.click(getByText('reset'))
await findByText('countA: 0, countB: 0, sum: 0')
fireEvent.click(getByText('incBoth'))
await findByText('countA: 1, countB: 1, sum: 2')
})
it('updates a derived atom in useEffect with two primitive atoms', async () => {
const countAAtom = atom(0)
const countBAtom = atom(1)
const sumAtom = atom((get) => get(countAAtom) + get(countBAtom))
const Counter = () => {
const [countA, setCountA] = useAtom(countAAtom)
const [countB, setCountB] = useAtom(countBAtom)
const [sum] = useAtom(sumAtom)
useEffect(() => {
setCountA((c) => c + 1)
}, [setCountA, countB])
return (
<>
<div>
countA: {countA}, countB: {countB}, sum: {sum}
</div>
<button onClick={() => setCountB((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<>
<Counter />
</>,
)
await findByText('countA: 1, countB: 1, sum: 2')
fireEvent.click(getByText('button'))
await findByText('countA: 2, countB: 2, sum: 4')
})
it('updates two atoms in child useEffect', async () => {
const countAAtom = atom(0)
const countBAtom = atom(10)
const Child = () => {
const [countB, setCountB] = useAtom(countBAtom)
useEffect(() => {
setCountB((c) => c + 1)
}, [setCountB])
return <div>countB: {countB}</div>
}
const Counter = () => {
const [countA, setCountA] = useAtom(countAAtom)
useEffect(() => {
setCountA((c) => c + 1)
}, [setCountA])
return (
<>
<div>countA: {countA}</div>
{countA > 0 && <Child />}
</>
)
}
const { getByText } = render(
<>
<Counter />
</>,
)
await waitFor(() => {
getByText('countA: 1')
getByText('countB: 11')
})
})
it('set atom right after useEffect (#208)', async () => {
const countAtom = atom(0)
const effectFn = vi.fn()
const Child = () => {
const [count, setCount] = useAtom(countAtom)
const [, setState] = useState(null)
// rAF does not repro, so schedule update intentionally in render
if (count === 1) {
Promise.resolve().then(() => {
setCount(2)
})
}
useEffect(() => {
effectFn(count)
setState(null) // this is important to repro (set something stable)
}, [count, setState])
return <div>count: {count}</div>
}
const Parent = () => {
const [, setCount] = useAtom(countAtom)
useEffect(() => {
setCount(1)
// requestAnimationFrame(() => setCount(2))
}, [setCount])
return <Child />
}
const { findByText } = render(
<StrictMode>
<Parent />
</StrictMode>,
)
await findByText('count: 2')
expect(effectFn).toHaveBeenLastCalledWith(2)
})
it('changes atom from parent (#273, #275)', async () => {
const atomA = atom({ id: 'a' })
const atomB = atom({ id: 'b' })
const Item = ({ id }: { id: string }) => {
const a = useMemo(() => (id === 'a' ? atomA : atomB), [id])
const [atomValue] = useAtom(a)
return (
<div>
commits: {useCommitCount()}, id: {atomValue.id}
</div>
)
}
const App = () => {
const [id, setId] = useState('a')
return (
<div>
<button onClick={() => setId('a')}>atom a</button>
<button onClick={() => setId('b')}>atom b</button>
<Item id={id} />
</div>
)
}
const { getByText, findByText } = render(
<>
<App />
</>,
)
await findByText('commits: 1, id: a')
fireEvent.click(getByText('atom a'))
await findByText('commits: 1, id: a')
fireEvent.click(getByText('atom b'))
await findByText('commits: 2, id: b')
fireEvent.click(getByText('atom a'))
await findByText('commits: 3, id: a')
})
it('should be able to use a double derived atom twice and useEffect (#373)', async () => {
const countAtom = atom(0)
const doubleAtom = atom((get) => get(countAtom) * 2)
const fourfoldAtom = atom((get) => get(doubleAtom) * 2)
const App = () => {
const [count, setCount] = useAtom(countAtom)
const [fourfold] = useAtom(fourfoldAtom)
const [fourfold2] = useAtom(fourfoldAtom)
useEffect(() => {
setCount(count)
}, [count, setCount])
return (
<div>
count: {count},{fourfold},{fourfold2}
<button onClick={() => setCount((c) => c + 1)}>one up</button>
</div>
)
}
const { getByText, findByText } = render(
<StrictMode>
<App />
</StrictMode>,
)
await findByText('count: 0,0,0')
fireEvent.click(getByText('one up'))
await findByText('count: 1,4,4')
})
it('write self atom (undocumented usage)', async () => {
const countAtom = atom(0, (get, set, _arg) => {
set(countAtom, get(countAtom) + 1)
})
const Counter = () => {
const [count, inc] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={inc}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('button'))
await findByText('count: 1')
})
it('async chain for multiple sync and async atoms (#443)', async () => {
const num1Atom = atom(async () => {
return 1
})
const num2Atom = atom(async () => {
return 2
})
// "async" is required to reproduce the issue
const sumAtom = atom(
async (get) => (await get(num1Atom)) + (await get(num2Atom)),
)
const countAtom = atom((get) => get(sumAtom))
const Counter = () => {
const [count] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
</>
)
}
const { findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('loading')
await findByText('count: 3')
})
it('sync re-renders with useState re-renders (#827)', async () => {
const atom0 = atom('atom0')
const atom1 = atom('atom1')
const atom2 = atom('atom2')
const atoms = [atom0, atom1, atom2]
const App = () => {
const [currentAtomIndex, setCurrentAtomIndex] = useState(0)
const rotateAtoms = () => {
setCurrentAtomIndex((prev) => (prev + 1) % atoms.length)
}
const [atomValue] = useAtom(
atoms[currentAtomIndex] as (typeof atoms)[number],
)
return (
<>
<span>commits: {useCommitCount()}</span>
<h1>{atomValue}</h1>
<button onClick={rotateAtoms}>rotate</button>
</>
)
}
const { findByText, getByText } = render(
<>
<App />
</>,
)
await findByText('commits: 1')
fireEvent.click(getByText('rotate'))
await findByText('commits: 2')
fireEvent.click(getByText('rotate'))
await findByText('commits: 3')
})
it('chained derive atom with onMount and useEffect (#897)', async () => {
const countAtom = atom(0)
countAtom.onMount = (set) => {
set(1)
}
const derivedAtom = atom((get) => get(countAtom))
const derivedObjectAtom = atom((get) => ({
count: get(derivedAtom),
}))
const Counter = () => {
const [, setCount] = useAtom(countAtom)
const [{ count }] = useAtom(derivedObjectAtom)
useEffect(() => {
setCount(1)
}, [setCount])
return <div>count: {count}</div>
}
const { findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 1')
})
it('onMount is not called when atom value is accessed from writeGetter in derived atom (#942)', async () => {
const onUnmount = vi.fn()
const onMount = vi.fn(() => {
return onUnmount
})
const aAtom = atom(false)
aAtom.onMount = onMount
const bAtom = atom(null, (get) => {
get(aAtom)
})
const App = () => {
const [, action] = useAtom(bAtom)
useEffect(() => action(), [action])
return null
}
render(
<StrictMode>
<App />
</StrictMode>,
)
expect(onMount).not.toHaveBeenCalled()
expect(onUnmount).not.toHaveBeenCalled()
})
it('useAtom returns consistent value with input with changing atoms (#1235)', async () => {
const countAtom = atom(0)
const valueAtoms = [atom(0), atom(1)]
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
const [value] = useAtom(valueAtoms[count] as PrimitiveAtom<number>)
if (count !== value) {
throw new Error('value mismatch')
}
return (
<>
<div>count: {count}</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('button'))
await findByText('count: 1')
})
|
6,830 | 0 | petrpan-code/pmndrs/jotai/tests | petrpan-code/pmndrs/jotai/tests/react/dependency.test.tsx | import { StrictMode, Suspense, useEffect, useRef, useState } from 'react'
import { fireEvent, render, waitFor } from '@testing-library/react'
import { describe, expect, it, vi } from 'vitest'
import { useAtom, useAtomValue, useSetAtom } from 'jotai/react'
import { atom } from 'jotai/vanilla'
import type { Atom, Getter } from 'jotai/vanilla'
const useCommitCount = () => {
const commitCountRef = useRef(1)
useEffect(() => {
commitCountRef.current += 1
})
return commitCountRef.current
}
it('works with 2 level dependencies', async () => {
const countAtom = atom(1)
const doubledAtom = atom((get) => get(countAtom) * 2)
const tripledAtom = atom((get) => get(doubledAtom) * 3)
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
const [doubledCount] = useAtom(doubledAtom)
const [tripledCount] = useAtom(tripledAtom)
return (
<>
<div>
commits: {useCommitCount()}, count: {count}, doubled: {doubledCount},
tripled: {tripledCount}
</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<>
<Counter />
</>,
)
await findByText('commits: 1, count: 1, doubled: 2, tripled: 6')
fireEvent.click(getByText('button'))
await findByText('commits: 2, count: 2, doubled: 4, tripled: 12')
})
it('works a primitive atom and a dependent async atom', async () => {
const countAtom = atom(1)
let resolve = () => {}
const doubledAtom = atom(async (get) => {
await new Promise<void>((r) => (resolve = r))
return get(countAtom) * 2
})
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
const [doubledCount] = useAtom(doubledAtom)
return (
<>
<div>
count: {count}, doubled: {doubledCount}
</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('loading')
resolve()
await findByText('count: 1, doubled: 2')
fireEvent.click(getByText('button'))
await findByText('loading')
resolve()
await findByText('count: 2, doubled: 4')
fireEvent.click(getByText('button'))
await findByText('loading')
resolve()
await findByText('count: 3, doubled: 6')
})
it('should keep an atom value even if unmounted', async () => {
const countAtom = atom(0)
const derivedFn = vi.fn((get: Getter) => get(countAtom))
const derivedAtom = atom(derivedFn)
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const DerivedCounter = () => {
const [derived] = useAtom(derivedAtom)
return <div>derived: {derived}</div>
}
const Parent = () => {
const [show, setShow] = useState(true)
return (
<div>
<button onClick={() => setShow((x) => !x)}>toggle</button>
{show ? (
<>
<Counter />
<DerivedCounter />
</>
) : (
<div>hidden</div>
)}
</div>
)
}
const { getByText } = render(
<StrictMode>
<Parent />
</StrictMode>,
)
await waitFor(() => {
getByText('count: 0')
getByText('derived: 0')
})
expect(derivedFn).toHaveReturnedTimes(1)
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('count: 1')
getByText('derived: 1')
})
expect(derivedFn).toHaveReturnedTimes(2)
fireEvent.click(getByText('toggle'))
await waitFor(() => {
getByText('hidden')
})
expect(derivedFn).toHaveReturnedTimes(2)
fireEvent.click(getByText('toggle'))
await waitFor(() => {
getByText('count: 1')
getByText('derived: 1')
})
expect(derivedFn).toHaveReturnedTimes(2)
})
it('should keep a dependent atom value even if unmounted', async () => {
const countAtom = atom(0)
const derivedFn = vi.fn((get: Getter) => get(countAtom))
const derivedAtom = atom(derivedFn)
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const DerivedCounter = () => {
const [derived] = useAtom(derivedAtom)
return <div>derived: {derived}</div>
}
const Parent = () => {
const [showDerived, setShowDerived] = useState(true)
return (
<div>
<button onClick={() => setShowDerived((x) => !x)}>toggle</button>
{showDerived ? <DerivedCounter /> : <Counter />}
</div>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Parent />
</StrictMode>,
)
await findByText('derived: 0')
expect(derivedFn).toHaveReturnedTimes(1)
fireEvent.click(getByText('toggle'))
await findByText('count: 0')
expect(derivedFn).toHaveReturnedTimes(1)
fireEvent.click(getByText('button'))
await findByText('count: 1')
expect(derivedFn).toHaveReturnedTimes(1)
fireEvent.click(getByText('toggle'))
await findByText('derived: 1')
expect(derivedFn).toHaveReturnedTimes(2)
})
it('should bail out updating if not changed', async () => {
const countAtom = atom(0)
const derivedFn = vi.fn((get: Getter) => get(countAtom))
const derivedAtom = atom(derivedFn)
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => setCount(0)}>button</button>
</>
)
}
const DerivedCounter = () => {
const [derived] = useAtom(derivedAtom)
return <div>derived: {derived}</div>
}
const { getByText } = render(
<StrictMode>
<Counter />
<DerivedCounter />
</StrictMode>,
)
await waitFor(() => {
getByText('count: 0')
getByText('derived: 0')
})
expect(derivedFn).toHaveReturnedTimes(1)
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('count: 0')
getByText('derived: 0')
})
expect(derivedFn).toHaveReturnedTimes(1)
})
it('should bail out updating if not changed, 2 level', async () => {
const dataAtom = atom({ count: 1, obj: { anotherCount: 10 } })
const getDataCountFn = vi.fn((get: Getter) => get(dataAtom).count)
const countAtom = atom(getDataCountFn)
const getDataObjFn = vi.fn((get: Getter) => get(dataAtom).obj)
const objAtom = atom(getDataObjFn)
const getAnotherCountFn = vi.fn((get: Getter) => get(objAtom).anotherCount)
const anotherCountAtom = atom(getAnotherCountFn)
const Counter = () => {
const [count] = useAtom(countAtom)
const [, setData] = useAtom(dataAtom)
return (
<>
<div>count: {count}</div>
<button
onClick={() =>
setData((prev) => ({ ...prev, count: prev.count + 1 }))
}
>
button
</button>
</>
)
}
const DerivedCounter = () => {
const [anotherCount] = useAtom(anotherCountAtom)
return <div>anotherCount: {anotherCount}</div>
}
const { getByText } = render(
<StrictMode>
<Counter />
<DerivedCounter />
</StrictMode>,
)
await waitFor(() => {
getByText('count: 1')
getByText('anotherCount: 10')
})
expect(getDataCountFn).toHaveReturnedTimes(1)
expect(getDataObjFn).toHaveReturnedTimes(1)
expect(getAnotherCountFn).toHaveReturnedTimes(1)
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('count: 2')
getByText('anotherCount: 10')
})
expect(getDataCountFn).toHaveReturnedTimes(2)
expect(getDataObjFn).toHaveReturnedTimes(2)
expect(getAnotherCountFn).toHaveReturnedTimes(1)
})
it('derived atom to update base atom in callback', async () => {
const countAtom = atom(1)
const doubledAtom = atom(
(get) => get(countAtom) * 2,
(_get, _set, callback: () => void) => {
callback()
},
)
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
const [doubledCount, dispatch] = useAtom(doubledAtom)
return (
<>
<div>
commits: {useCommitCount()}, count: {count}, doubled: {doubledCount}
</div>
<button onClick={() => dispatch(() => setCount((c) => c + 1))}>
button
</button>
</>
)
}
const { getByText, findByText } = render(
<>
<Counter />
</>,
)
await findByText('commits: 1, count: 1, doubled: 2')
fireEvent.click(getByText('button'))
await findByText('commits: 2, count: 2, doubled: 4')
})
it('can read sync derived atom in write without initializing', async () => {
const countAtom = atom(1)
const doubledAtom = atom((get) => get(countAtom) * 2)
const addAtom = atom(null, (get, set, num: number) => {
set(countAtom, get(doubledAtom) / 2 + num)
})
const Counter = () => {
const [count] = useAtom(countAtom)
const [, add] = useAtom(addAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => add(1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 1')
fireEvent.click(getByText('button'))
await findByText('count: 2')
fireEvent.click(getByText('button'))
await findByText('count: 3')
})
it('can remount atoms with dependency (#490)', async () => {
const countAtom = atom(0)
const derivedAtom = atom((get) => get(countAtom))
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const DerivedCounter = () => {
const [derived] = useAtom(derivedAtom)
return <div>derived: {derived}</div>
}
const Parent = () => {
const [showChildren, setShowChildren] = useState(true)
return (
<div>
<button onClick={() => setShowChildren((x) => !x)}>toggle</button>
{showChildren ? (
<>
<Counter />
<DerivedCounter />
</>
) : (
<div>hidden</div>
)}
</div>
)
}
const { getByText } = render(
<StrictMode>
<Parent />
</StrictMode>,
)
await waitFor(() => {
getByText('count: 0')
getByText('derived: 0')
})
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('count: 1')
getByText('derived: 1')
})
fireEvent.click(getByText('toggle'))
await waitFor(() => {
getByText('hidden')
})
fireEvent.click(getByText('toggle'))
await waitFor(() => {
getByText('count: 1')
getByText('derived: 1')
})
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('count: 2')
getByText('derived: 2')
})
})
it('can remount atoms with intermediate atom', async () => {
const countAtom = atom(1)
const resultAtom = atom(0)
const intermediateAtom = atom((get) => {
const count = get(countAtom)
const initAtom = atom(null, (_get, set) => {
set(resultAtom, count * 2)
})
initAtom.onMount = (init) => {
init()
}
return initAtom
})
const derivedAtom = atom((get) => {
const initAtom = get(intermediateAtom)
get(initAtom)
return get(resultAtom)
})
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const DerivedCounter = () => {
const [derived] = useAtom(derivedAtom)
return <div>derived: {derived}</div>
}
const Parent = () => {
const [showChildren, setShowChildren] = useState(true)
return (
<div>
<Counter />
<button onClick={() => setShowChildren((x) => !x)}>toggle</button>
{showChildren ? <DerivedCounter /> : <div>hidden</div>}
</div>
)
}
const { getByText } = render(
<StrictMode>
<Parent />
</StrictMode>,
)
await waitFor(() => {
getByText('count: 1')
getByText('derived: 2')
})
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('count: 2')
getByText('derived: 4')
})
fireEvent.click(getByText('toggle'))
await waitFor(() => {
getByText('count: 2')
getByText('hidden')
})
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('count: 3')
getByText('hidden')
})
fireEvent.click(getByText('toggle'))
await waitFor(() => {
getByText('count: 3')
getByText('derived: 6')
})
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('count: 4')
getByText('derived: 8')
})
})
it('can update dependents with useEffect (#512)', async () => {
const enabledAtom = atom(false)
const countAtom = atom(1)
const derivedAtom = atom((get) => {
const enabled = get(enabledAtom)
if (!enabled) {
return 0
}
const count = get(countAtom)
return count * 2
})
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const DerivedCounter = () => {
const [derived] = useAtom(derivedAtom)
return <div>derived: {derived}</div>
}
const Parent = () => {
const [, setEnabled] = useAtom(enabledAtom)
useEffect(() => {
setEnabled(true)
}, [setEnabled])
return (
<div>
<Counter />
<DerivedCounter />
</div>
)
}
const { getByText } = render(
<StrictMode>
<Parent />
</StrictMode>,
)
await waitFor(() => {
getByText('count: 1')
getByText('derived: 2')
})
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('count: 2')
getByText('derived: 4')
})
})
it('update unmounted atom with intermediate atom', async () => {
const enabledAtom = atom(true)
const countAtom = atom(1)
const intermediateAtom = atom((get) => {
const count = get(countAtom)
const enabled = get(enabledAtom)
const tmpAtom = atom(enabled ? count * 2 : -1)
return tmpAtom
})
const derivedAtom = atom((get) => {
const tmpAtom = get(intermediateAtom)
return get(tmpAtom)
})
const DerivedCounter = () => {
const [derived] = useAtom(derivedAtom)
return <div>derived: {derived}</div>
}
const Control = () => {
const [, setEnabled] = useAtom(enabledAtom)
const [, setCount] = useAtom(countAtom)
return (
<>
<button onClick={() => setCount((c) => c + 1)}>increment count</button>
<button onClick={() => setEnabled((x) => !x)}>toggle enabled</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<DerivedCounter />
<Control />
</StrictMode>,
)
await findByText('derived: 2')
fireEvent.click(getByText('toggle enabled'))
fireEvent.click(getByText('increment count'))
await findByText('derived: -1')
fireEvent.click(getByText('toggle enabled'))
await findByText('derived: 4')
})
it('Should bail for derived sync chains (#877)', async () => {
let syncAtomCount = 0
const textAtom = atom('hello')
const syncAtom = atom((get) => {
get(textAtom)
syncAtomCount++
return 'My very long data'
})
const derivedAtom = atom((get) => {
return get(syncAtom)
})
const Input = () => {
const [result] = useAtom(derivedAtom)
return <div>{result}</div>
}
const ForceValue = () => {
const setText = useAtom(textAtom)[1]
return (
<div>
<button onClick={() => setText('hello')}>set value to 'hello'</button>
</div>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Input />
<ForceValue />
</StrictMode>,
)
await findByText('My very long data')
expect(syncAtomCount).toBe(1)
fireEvent.click(getByText(`set value to 'hello'`))
await findByText('My very long data')
expect(syncAtomCount).toBe(1)
})
it('Should bail for derived async chains (#877)', async () => {
let syncAtomCount = 0
const textAtom = atom('hello')
const asyncAtom = atom(async (get) => {
get(textAtom)
syncAtomCount++
return 'My very long data'
})
const derivedAtom = atom((get) => {
return get(asyncAtom)
})
const Input = () => {
const [result] = useAtom(derivedAtom)
return <div>{result}</div>
}
const ForceValue = () => {
const setText = useAtom(textAtom)[1]
return (
<div>
<button onClick={() => setText('hello')}>set value to 'hello'</button>
</div>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Input />
<ForceValue />
</Suspense>
</StrictMode>,
)
await findByText('My very long data')
expect(syncAtomCount).toBe(1)
fireEvent.click(getByText(`set value to 'hello'`))
await findByText('My very long data')
expect(syncAtomCount).toBe(1)
})
it('update correctly with async updates (#1250)', async () => {
const countAtom = atom(0)
const countIsGreaterThanOneAtom = atom((get) => get(countAtom) > 1)
const alsoCountAtom = atom((get) => {
const count = get(countAtom)
get(countIsGreaterThanOneAtom)
return count
})
const App = () => {
const setCount = useSetAtom(countAtom)
const alsoCount = useAtomValue(alsoCountAtom)
const countIsGreaterThanOne = useAtomValue(countIsGreaterThanOneAtom)
const incrementCountTwice = () => {
setTimeout(() => setCount((count) => count + 1))
setTimeout(() => setCount((count) => count + 1))
}
return (
<div>
<button onClick={incrementCountTwice}>Increment Count Twice</button>
<div>alsoCount: {alsoCount}</div>
<div>countIsGreaterThanOne: {countIsGreaterThanOne.toString()}</div>
</div>
)
}
const { getByText } = render(
<StrictMode>
<App />
</StrictMode>,
)
await waitFor(() => {
getByText('alsoCount: 0')
getByText('countIsGreaterThanOne: false')
})
fireEvent.click(getByText('Increment Count Twice'))
await waitFor(() => {
getByText('alsoCount: 2')
getByText('countIsGreaterThanOne: true')
})
})
describe('glitch free', () => {
it('basic', async () => {
const baseAtom = atom(0)
const derived1Atom = atom((get) => get(baseAtom))
const derived2Atom = atom((get) => get(derived1Atom))
const computeValue = vi.fn((get: Getter) => {
const v0 = get(baseAtom)
const v1 = get(derived1Atom)
const v2 = get(derived2Atom)
return `v0: ${v0}, v1: ${v1}, v2: ${v2}`
})
const derived3Atom = atom(computeValue)
const App = () => {
const value = useAtomValue(derived3Atom)
return <div>value: {value}</div>
}
const Control = () => {
const setCount = useSetAtom(baseAtom)
return (
<>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<App />
<Control />
</StrictMode>,
)
await findByText('value: v0: 0, v1: 0, v2: 0')
expect(computeValue).toHaveBeenCalledTimes(1)
fireEvent.click(getByText('button'))
await findByText('value: v0: 1, v1: 1, v2: 1')
expect(computeValue).toHaveBeenCalledTimes(2)
})
it('same value', async () => {
const baseAtom = atom(0)
const derived1Atom = atom((get) => get(baseAtom) * 0)
const derived2Atom = atom((get) => get(derived1Atom) * 0)
const computeValue = vi.fn((get: Getter) => {
const v0 = get(baseAtom)
const v1 = get(derived1Atom)
const v2 = get(derived2Atom)
return v0 + (v1 - v2)
})
const derived3Atom = atom(computeValue)
const App = () => {
const value = useAtomValue(derived3Atom)
return <div>value: {value}</div>
}
const Control = () => {
const setCount = useSetAtom(baseAtom)
return (
<>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<App />
<Control />
</StrictMode>,
)
await findByText('value: 0')
expect(computeValue).toHaveBeenCalledTimes(1)
fireEvent.click(getByText('button'))
await findByText('value: 1')
expect(computeValue).toHaveBeenCalledTimes(2)
})
it('double chain', async () => {
const baseAtom = atom(0)
const derived1Atom = atom((get) => get(baseAtom))
const derived2Atom = atom((get) => get(derived1Atom))
const derived3Atom = atom((get) => get(derived2Atom))
const computeValue = vi.fn((get: Getter) => {
const v0 = get(baseAtom)
const v1 = get(derived1Atom)
const v2 = get(derived2Atom)
const v3 = get(derived3Atom)
return v0 + (v1 - v2) + v3 * 0
})
const derived4Atom = atom(computeValue)
const App = () => {
const value = useAtomValue(derived4Atom)
return <div>value: {value}</div>
}
const Control = () => {
const setCount = useSetAtom(baseAtom)
return (
<>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<App />
<Control />
</StrictMode>,
)
await findByText('value: 0')
expect(computeValue).toHaveBeenCalledTimes(1)
fireEvent.click(getByText('button'))
await findByText('value: 1')
expect(computeValue).toHaveBeenCalledTimes(2)
})
})
it('should not call read function for unmounted atoms in StrictMode (#2076)', async () => {
const countAtom = atom(1)
let firstDerivedFn: ReturnType<typeof vi.fn> | undefined
const Component = () => {
const memoizedAtomRef = useRef<Atom<number> | null>(null)
if (!memoizedAtomRef.current) {
const derivedFn = vi.fn((get: Getter) => get(countAtom))
if (!firstDerivedFn) {
firstDerivedFn = derivedFn
}
memoizedAtomRef.current = atom(derivedFn)
}
useAtomValue(memoizedAtomRef.current)
return null
}
const Main = () => {
const [show, setShow] = useState(true)
const setCount = useSetAtom(countAtom)
return (
<>
<button onClick={() => setShow(false)}>hide</button>
<button
onClick={() => {
setShow(true)
setCount((c) => c + 1)
}}
>
show
</button>
{show && <Component />}
</>
)
}
const { getByText } = render(
<StrictMode>
<Main />
</StrictMode>,
)
fireEvent.click(getByText('hide'))
expect(firstDerivedFn).toBeCalledTimes(1)
firstDerivedFn?.mockClear()
fireEvent.click(getByText('show'))
expect(firstDerivedFn).toBeCalledTimes(0)
})
|
6,831 | 0 | petrpan-code/pmndrs/jotai/tests | petrpan-code/pmndrs/jotai/tests/react/error.test.tsx | import { Component, StrictMode, Suspense, useEffect, useState } from 'react'
import type { ReactNode } from 'react'
import { fireEvent, render, waitFor } from '@testing-library/react'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { useAtom } from 'jotai/react'
import { atom } from 'jotai/vanilla'
const consoleError = console.error
const errorMessages: string[] = []
beforeEach(() => {
errorMessages.splice(0)
console.error = vi.fn((err: string) => {
const match = /^(.*?)(\n|$)/.exec(err)
if (match?.[1]) {
errorMessages.push(match[1])
}
})
})
afterEach(() => {
console.error = consoleError
})
class ErrorBoundary extends Component<
{ message?: string; children: ReactNode },
{ hasError: boolean }
> {
constructor(props: { message?: string; children: ReactNode }) {
super(props)
this.state = { hasError: false }
}
static getDerivedStateFromError() {
return { hasError: true }
}
render() {
return this.state.hasError ? (
<div>
{this.props.message || 'errored'}
<button onClick={() => this.setState({ hasError: false })}>
retry
</button>
</div>
) : (
this.props.children
)
}
}
it('can throw an initial error in read function', async () => {
const errorAtom = atom(() => {
throw new Error()
})
const Counter = () => {
useAtom(errorAtom)
return (
<>
<div>no error</div>
</>
)
}
const { findByText } = render(
<StrictMode>
<ErrorBoundary>
<Counter />
</ErrorBoundary>
</StrictMode>,
)
await findByText('errored')
})
it('can throw an error in read function', async () => {
const countAtom = atom(0)
const errorAtom = atom((get) => {
if (get(countAtom) === 0) {
return 0
}
throw new Error()
})
const Counter = () => {
const [, setCount] = useAtom(countAtom)
const [count] = useAtom(errorAtom)
return (
<>
<div>count: {count}</div>
<div>no error</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<ErrorBoundary>
<Counter />
</ErrorBoundary>
</StrictMode>,
)
await findByText('no error')
fireEvent.click(getByText('button'))
await findByText('errored')
})
it('can throw an initial chained error in read function', async () => {
const errorAtom = atom(() => {
throw new Error()
})
const derivedAtom = atom((get) => get(errorAtom))
const Counter = () => {
useAtom(derivedAtom)
return (
<>
<div>no error</div>
</>
)
}
const { findByText } = render(
<StrictMode>
<ErrorBoundary>
<Counter />
</ErrorBoundary>
</StrictMode>,
)
await findByText('errored')
})
it('can throw a chained error in read function', async () => {
const countAtom = atom(0)
const errorAtom = atom((get) => {
if (get(countAtom) === 0) {
return 0
}
throw new Error()
})
const derivedAtom = atom((get) => get(errorAtom))
const Counter = () => {
const [, setCount] = useAtom(countAtom)
const [count] = useAtom(derivedAtom)
return (
<>
<div>count: {count}</div>
<div>no error</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<ErrorBoundary>
<Counter />
</ErrorBoundary>
</StrictMode>,
)
await findByText('no error')
fireEvent.click(getByText('button'))
await findByText('errored')
})
it('can throw an initial error in async read function', async () => {
const errorAtom = atom(async () => {
throw new Error()
})
const Counter = () => {
useAtom(errorAtom)
return (
<>
<div>no error</div>
</>
)
}
const { findByText } = render(
<StrictMode>
<ErrorBoundary>
<Suspense fallback={null}>
<Counter />
</Suspense>
</ErrorBoundary>
</StrictMode>,
)
await findByText('errored')
})
it('can throw an error in async read function', async () => {
const countAtom = atom(0)
const errorAtom = atom(async (get) => {
if (get(countAtom) === 0) {
return 0
}
throw new Error()
})
const Counter = () => {
const [, setCount] = useAtom(countAtom)
const [count] = useAtom(errorAtom)
return (
<>
<div>count: {count}</div>
<div>no error</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<ErrorBoundary>
<Suspense fallback={null}>
<Counter />
</Suspense>
</ErrorBoundary>
</StrictMode>,
)
await findByText('no error')
fireEvent.click(getByText('button'))
await findByText('errored')
})
it('can throw an error in write function', async () => {
const countAtom = atom(0)
const errorAtom = atom(
(get) => get(countAtom),
() => {
throw new Error('error_in_write_function')
},
)
const Counter = () => {
const [count, dispatch] = useAtom(errorAtom)
const onClick = () => {
try {
dispatch()
} catch (e) {
console.error(e)
}
}
return (
<>
<div>count: {count}</div>
<div>no error</div>
<button onClick={onClick}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('no error')
expect(errorMessages).not.toContain('Error: error_in_write_function')
fireEvent.click(getByText('button'))
expect(errorMessages).toContain('Error: error_in_write_function')
})
it('can throw an error in async write function', async () => {
const countAtom = atom(0)
const errorAtom = atom(
(get) => get(countAtom),
async () => {
throw new Error('error_in_async_write_function')
},
)
const Counter = () => {
const [count, dispatch] = useAtom(errorAtom)
const onClick = async () => {
try {
await dispatch()
} catch (e) {
console.error(e)
}
}
return (
<>
<div>count: {count}</div>
<div>no error</div>
<button onClick={onClick}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Suspense fallback={null}>
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('no error')
expect(errorMessages).not.toContain('Error: error_in_async_write_function')
fireEvent.click(getByText('button'))
await waitFor(() => {
expect(errorMessages).toContain('Error: error_in_async_write_function')
})
})
it('can throw a chained error in write function', async () => {
const countAtom = atom(0)
const errorAtom = atom(
(get) => get(countAtom),
() => {
throw new Error('chained_err_in_write')
},
)
const chainedAtom = atom(
(get) => get(errorAtom),
(_get, set) => {
set(errorAtom)
},
)
const Counter = () => {
const [count, dispatch] = useAtom(chainedAtom)
const onClick = () => {
try {
dispatch()
} catch (e) {
console.error(e)
}
}
return (
<>
<div>count: {count}</div>
<div>no error</div>
<button onClick={onClick}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('no error')
expect(errorMessages).not.toContain('Error: chained_err_in_write')
fireEvent.click(getByText('button'))
expect(errorMessages).toContain('Error: chained_err_in_write')
})
it('throws an error while updating in effect', async () => {
const countAtom = atom(0)
const Counter = () => {
const [, setCount] = useAtom(countAtom)
useEffect(() => {
try {
setCount(() => {
throw new Error('err_updating_in_effect')
})
} catch (e) {
console.error(e)
}
}, [setCount])
return (
<>
<div>no error</div>
</>
)
}
const { findByText } = render(
<StrictMode>
<ErrorBoundary>
<Counter />
</ErrorBoundary>
</StrictMode>,
)
await findByText('no error')
expect(errorMessages).toContain('Error: err_updating_in_effect')
})
describe('throws an error while updating in effect cleanup', () => {
const countAtom = atom(0)
let doubleSetCount = false
const Counter = () => {
const [, setCount] = useAtom(countAtom)
useEffect(() => {
return () => {
if (doubleSetCount) {
setCount((x) => x + 1)
}
setCount(() => {
throw new Error('err_in_effect_cleanup')
})
}
}, [setCount])
return (
<>
<div>no error</div>
</>
)
}
const Main = () => {
const [hide, setHide] = useState(false)
return (
<>
<button onClick={() => setHide(true)}>close</button>
{!hide && <Counter />}
</>
)
}
it('[DEV-ONLY] single setCount', async () => {
const { getByText, findByText } = render(
<>
<ErrorBoundary>
<Main />
</ErrorBoundary>
</>,
)
await findByText('no error')
expect(errorMessages).not.toContain(
'Error: Uncaught [Error: err_in_effect_cleanup]',
)
fireEvent.click(getByText('close'))
expect(errorMessages).toContain(
'Error: Uncaught [Error: err_in_effect_cleanup]',
)
})
it('[DEV-ONLY] dobule setCount', async () => {
doubleSetCount = true
const { getByText, findByText } = render(
<>
<ErrorBoundary>
<Main />
</ErrorBoundary>
</>,
)
await findByText('no error')
expect(errorMessages).not.toContain(
'Error: Uncaught [Error: err_in_effect_cleanup]',
)
fireEvent.click(getByText('close'))
expect(errorMessages).toContain(
'Error: Uncaught [Error: err_in_effect_cleanup]',
)
})
})
describe('error recovery', () => {
const createCounter = () => {
const counterAtom = atom(0)
const Counter = () => {
const [count, setCount] = useAtom(counterAtom)
return <button onClick={() => setCount(count + 1)}>increment</button>
}
return { Counter, counterAtom }
}
it('recovers from sync errors', async () => {
const { counterAtom, Counter } = createCounter()
const syncAtom = atom((get) => {
const value = get(counterAtom)
if (value === 0) {
throw new Error('An error occurred')
}
return value
})
const Display = () => {
return <div>Value: {useAtom(syncAtom)[0]}</div>
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
<ErrorBoundary>
<Display />
</ErrorBoundary>
</StrictMode>,
)
await findByText('errored')
fireEvent.click(getByText('increment'))
fireEvent.click(getByText('retry'))
await findByText('Value: 1')
})
it('recovers from async errors', async () => {
const { counterAtom, Counter } = createCounter()
let resolve = () => {}
const asyncAtom = atom(async (get) => {
const value = get(counterAtom)
await new Promise<void>((r) => (resolve = r))
if (value === 0) {
throw new Error('An error occurred')
}
return value
})
const Display = () => {
return <div>Value: {useAtom(asyncAtom)[0]}</div>
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
<ErrorBoundary>
<Suspense fallback={null}>
<Display />
</Suspense>
</ErrorBoundary>
</StrictMode>,
)
resolve()
await findByText('errored')
fireEvent.click(getByText('increment'))
fireEvent.click(getByText('retry'))
resolve()
await findByText('Value: 1')
})
})
|
6,832 | 0 | petrpan-code/pmndrs/jotai/tests | petrpan-code/pmndrs/jotai/tests/react/items.test.tsx | import { StrictMode } from 'react'
import { fireEvent, render, waitFor } from '@testing-library/react'
import { it } from 'vitest'
import { useAtom } from 'jotai/react'
import { atom } from 'jotai/vanilla'
import type { PrimitiveAtom } from 'jotai/vanilla'
it('remove an item, then add another', async () => {
type Item = {
text: string
checked: boolean
}
let itemIndex = 0
const itemsAtom = atom<PrimitiveAtom<Item>[]>([])
const ListItem = ({
itemAtom,
remove,
}: {
itemAtom: PrimitiveAtom<Item>
remove: () => void
}) => {
const [item, setItem] = useAtom(itemAtom)
const toggle = () =>
setItem((prev) => ({ ...prev, checked: !prev.checked }))
return (
<>
<div>
{item.text} checked: {item.checked ? 'yes' : 'no'}
</div>
<button onClick={toggle}>Check {item.text}</button>
<button onClick={remove}>Remove {item.text}</button>
</>
)
}
const List = () => {
const [items, setItems] = useAtom(itemsAtom)
const addItem = () => {
setItems((prev) => [
...prev,
atom<Item>({ text: `item${++itemIndex}`, checked: false }),
])
}
const removeItem = (itemAtom: PrimitiveAtom<Item>) => {
setItems((prev) => prev.filter((x) => x !== itemAtom))
}
return (
<ul>
{items.map((itemAtom) => (
<ListItem
key={`${itemAtom}`}
itemAtom={itemAtom}
remove={() => removeItem(itemAtom)}
/>
))}
<li>
<button onClick={addItem}>Add</button>
</li>
</ul>
)
}
const { getByText, findByText } = render(
<StrictMode>
<List />
</StrictMode>,
)
fireEvent.click(getByText('Add'))
await findByText('item1 checked: no')
fireEvent.click(getByText('Add'))
await waitFor(() => {
getByText('item1 checked: no')
getByText('item2 checked: no')
})
fireEvent.click(getByText('Check item2'))
await waitFor(() => {
getByText('item1 checked: no')
getByText('item2 checked: yes')
})
fireEvent.click(getByText('Remove item1'))
await findByText('item2 checked: yes')
fireEvent.click(getByText('Add'))
await waitFor(() => {
getByText('item2 checked: yes')
getByText('item3 checked: no')
})
})
it('add an item with filtered list', async () => {
type Item = {
text: string
checked: boolean
}
type ItemAtoms = PrimitiveAtom<Item>[]
type Update = (prev: ItemAtoms) => ItemAtoms
let itemIndex = 0
const itemAtomsAtom = atom<ItemAtoms>([])
const setItemsAtom = atom(null, (_get, set, update: Update) =>
set(itemAtomsAtom, update),
)
const filterAtom = atom<'all' | 'checked' | 'not-checked'>('all')
const filteredAtom = atom((get) => {
const filter = get(filterAtom)
const items = get(itemAtomsAtom)
if (filter === 'all') {
return items
}
if (filter === 'checked') {
return items.filter((atom) => get(atom).checked)
}
return items.filter((atom) => !get(atom).checked)
})
const ListItem = ({
itemAtom,
remove,
}: {
itemAtom: PrimitiveAtom<Item>
remove: () => void
}) => {
const [item, setItem] = useAtom(itemAtom)
const toggle = () =>
setItem((prev) => ({ ...prev, checked: !prev.checked }))
return (
<>
<div>
{item.text} checked: {item.checked ? 'yes' : 'no'}
</div>
<button onClick={toggle}>Check {item.text}</button>
<button onClick={remove}>Remove {item.text}</button>
</>
)
}
const Filter = () => {
const [filter, setFilter] = useAtom(filterAtom)
return (
<>
<div>{filter}</div>
<button onClick={() => setFilter('all')}>All</button>
<button onClick={() => setFilter('checked')}>Checked</button>
<button onClick={() => setFilter('not-checked')}>Not Checked</button>
</>
)
}
const FilteredList = ({
removeItem,
}: {
removeItem: (itemAtom: PrimitiveAtom<Item>) => void
}) => {
const [items] = useAtom(filteredAtom)
return (
<ul>
{items.map((itemAtom) => (
<ListItem
key={`${itemAtom}`}
itemAtom={itemAtom}
remove={() => removeItem(itemAtom)}
/>
))}
</ul>
)
}
const List = () => {
const [, setItems] = useAtom(setItemsAtom)
const addItem = () => {
setItems((prev) => [
...prev,
atom<Item>({ text: `item${++itemIndex}`, checked: false }),
])
}
const removeItem = (itemAtom: PrimitiveAtom<Item>) => {
setItems((prev) => prev.filter((x) => x !== itemAtom))
}
return (
<>
<Filter />
<button onClick={addItem}>Add</button>
<FilteredList removeItem={removeItem} />
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<List />
</StrictMode>,
)
fireEvent.click(getByText('Checked'))
fireEvent.click(getByText('Add'))
fireEvent.click(getByText('All'))
await findByText('item1 checked: no')
})
|
6,833 | 0 | petrpan-code/pmndrs/jotai/tests | petrpan-code/pmndrs/jotai/tests/react/onmount.test.tsx | import { StrictMode, Suspense, useState } from 'react'
import { act, fireEvent, render, waitFor } from '@testing-library/react'
import { expect, it, vi } from 'vitest'
import { useAtom } from 'jotai/react'
import { atom } from 'jotai/vanilla'
it('one atom, one effect', async () => {
const countAtom = atom(1)
const onMountFn = vi.fn(() => {})
countAtom.onMount = onMountFn
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<>
<Counter />
</>,
)
await findByText('count: 1')
expect(onMountFn).toHaveBeenCalledTimes(1)
fireEvent.click(getByText('button'))
await findByText('count: 2')
expect(onMountFn).toHaveBeenCalledTimes(1)
})
it('two atoms, one each', async () => {
const countAtom = atom(1)
const countAtom2 = atom(1)
const onMountFn = vi.fn(() => {})
const onMountFn2 = vi.fn(() => {})
countAtom.onMount = onMountFn
countAtom2.onMount = onMountFn2
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
const [count2, setCount2] = useAtom(countAtom2)
return (
<>
<div>count: {count}</div>
<div>count2: {count2}</div>
<button
onClick={() => {
setCount((c) => c + 1)
setCount2((c) => c + 1)
}}
>
button
</button>
</>
)
}
const { getByText } = render(
<>
<Counter />
</>,
)
await waitFor(() => {
getByText('count: 1')
getByText('count2: 1')
})
expect(onMountFn).toHaveBeenCalledTimes(1)
expect(onMountFn2).toHaveBeenCalledTimes(1)
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('count: 2')
getByText('count2: 2')
})
expect(onMountFn).toHaveBeenCalledTimes(1)
expect(onMountFn2).toHaveBeenCalledTimes(1)
})
it('one derived atom, one onMount', async () => {
const countAtom = atom(1)
const countAtom2 = atom((get) => get(countAtom))
const onMountFn = vi.fn(() => {})
countAtom.onMount = onMountFn
const Counter = () => {
const [count] = useAtom(countAtom2)
return (
<>
<div>count: {count}</div>
</>
)
}
const { findByText } = render(
<>
<Counter />
</>,
)
await findByText('count: 1')
expect(onMountFn).toHaveBeenCalledTimes(1)
})
it('mount/unmount test', async () => {
const countAtom = atom(1)
const onUnMountFn = vi.fn()
const onMountFn = vi.fn(() => onUnMountFn)
countAtom.onMount = onMountFn
const Counter = () => {
const [count] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
</>
)
}
const Display = () => {
const [display, setDisplay] = useState(true)
return (
<>
{display ? <Counter /> : null}
<button onClick={() => setDisplay((c) => !c)}>button</button>
</>
)
}
const { getByText } = render(
<>
<Display />
</>,
)
expect(onMountFn).toHaveBeenCalledTimes(1)
expect(onUnMountFn).toHaveBeenCalledTimes(0)
fireEvent.click(getByText('button'))
await waitFor(() => {
expect(onMountFn).toHaveBeenCalledTimes(1)
expect(onUnMountFn).toHaveBeenCalledTimes(1)
})
})
it('one derived atom, one onMount for the derived one, and one for the regular atom + onUnMount', async () => {
const countAtom = atom(1)
const derivedAtom = atom(
(get) => get(countAtom),
(_get, set, update: number) => {
set(countAtom, update)
set(derivedAtom, update)
},
)
const onUnMountFn = vi.fn()
const onMountFn = vi.fn(() => onUnMountFn)
countAtom.onMount = onMountFn
const derivedOnUnMountFn = vi.fn()
const derivedOnMountFn = vi.fn(() => derivedOnUnMountFn)
derivedAtom.onMount = derivedOnMountFn
const Counter = () => {
const [count] = useAtom(derivedAtom)
return (
<>
<div>count: {count}</div>
</>
)
}
const Display = () => {
const [display, setDisplay] = useState(true)
return (
<>
{display ? <Counter /> : null}
<button onClick={() => setDisplay((c) => !c)}>button</button>
</>
)
}
const { getByText } = render(
<>
<Display />
</>,
)
expect(derivedOnMountFn).toHaveBeenCalledTimes(1)
expect(derivedOnUnMountFn).toHaveBeenCalledTimes(0)
expect(onMountFn).toHaveBeenCalledTimes(1)
expect(onUnMountFn).toHaveBeenCalledTimes(0)
fireEvent.click(getByText('button'))
await waitFor(() => {
expect(derivedOnMountFn).toHaveBeenCalledTimes(1)
expect(derivedOnUnMountFn).toHaveBeenCalledTimes(1)
expect(onMountFn).toHaveBeenCalledTimes(1)
expect(onUnMountFn).toHaveBeenCalledTimes(1)
})
})
it('mount/unMount order', async () => {
const committed: number[] = [0, 0]
const countAtom = atom(1)
const derivedAtom = atom(
(get) => get(countAtom),
(_get, set, update: number) => {
set(countAtom, update)
set(derivedAtom, update)
},
)
const onUnMountFn = vi.fn(() => {
committed[0] = 0
})
const onMountFn = vi.fn(() => {
committed[0] = 1
return onUnMountFn
})
countAtom.onMount = onMountFn
const derivedOnUnMountFn = vi.fn(() => {
committed[1] = 0
})
const derivedOnMountFn = vi.fn(() => {
committed[1] = 1
return derivedOnUnMountFn
})
derivedAtom.onMount = derivedOnMountFn
const Counter2 = () => {
const [count] = useAtom(derivedAtom)
return (
<>
<div>count: {count}</div>
</>
)
}
const Counter = () => {
const [count] = useAtom(countAtom)
const [display, setDisplay] = useState(false)
return (
<>
<div>count: {count}</div>
<button onClick={() => setDisplay((c) => !c)}>derived atom</button>
{display ? <Counter2 /> : null}
</>
)
}
const Display = () => {
const [display, setDisplay] = useState(false)
return (
<>
{display ? <Counter /> : null}
<button onClick={() => setDisplay((c) => !c)}>button</button>
</>
)
}
const { getByText } = render(
<StrictMode>
<Display />
</StrictMode>,
)
expect(committed).toEqual([0, 0])
fireEvent.click(getByText('button'))
await waitFor(() => {
expect(committed).toEqual([1, 0])
})
fireEvent.click(getByText('derived atom'))
await waitFor(() => {
expect(committed).toEqual([1, 1])
})
fireEvent.click(getByText('derived atom'))
await waitFor(() => {
expect(committed).toEqual([1, 0])
})
fireEvent.click(getByText('button'))
await waitFor(() => {
expect(committed).toEqual([0, 0])
})
})
it('mount/unmount test with async atom', async () => {
let resolve = () => {}
const countAtom = atom(
async () => {
await new Promise<void>((r) => (resolve = r))
return 0
},
() => {},
)
const onUnMountFn = vi.fn()
const onMountFn = vi.fn(() => onUnMountFn)
countAtom.onMount = onMountFn
const Counter = () => {
const [count] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
</>
)
}
const Display = () => {
const [display, setDisplay] = useState(true)
return (
<>
{display ? <Counter /> : null}
<button onClick={() => setDisplay((c) => !c)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<>
<Suspense fallback="loading">
<Display />
</Suspense>
</>,
)
await findByText('loading')
resolve()
await findByText('count: 0')
expect(onMountFn).toHaveBeenCalledTimes(1)
expect(onUnMountFn).toHaveBeenCalledTimes(0)
fireEvent.click(getByText('button'))
expect(onMountFn).toHaveBeenCalledTimes(1)
expect(onUnMountFn).toHaveBeenCalledTimes(1)
})
it('subscription usage test', async () => {
const store = {
count: 10,
listeners: new Set<() => void>(),
inc: () => {
store.count += 1
store.listeners.forEach((listener) => listener())
},
}
const countAtom = atom(1)
countAtom.onMount = (setCount) => {
const callback = () => {
setCount(store.count)
}
store.listeners.add(callback)
callback()
return () => store.listeners.delete(callback)
}
const Counter = () => {
const [count] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
</>
)
}
const Display = () => {
const [display, setDisplay] = useState(true)
return (
<>
{display ? <Counter /> : 'N/A'}
<button onClick={() => setDisplay((c) => !c)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Display />
</StrictMode>,
)
await findByText('count: 10')
act(() => {
store.inc()
})
await findByText('count: 11')
fireEvent.click(getByText('button'))
await findByText('N/A')
fireEvent.click(getByText('button'))
await findByText('count: 11')
fireEvent.click(getByText('button'))
await findByText('N/A')
act(() => {
store.inc()
})
await findByText('N/A')
fireEvent.click(getByText('button'))
await findByText('count: 12')
})
it('subscription in base atom test', async () => {
const store = {
count: 10,
listeners: new Set<() => void>(),
add: (n: number) => {
store.count += n
store.listeners.forEach((listener) => listener())
},
}
const countAtom = atom(1)
countAtom.onMount = (setCount) => {
const callback = () => {
setCount(store.count)
}
store.listeners.add(callback)
callback()
return () => store.listeners.delete(callback)
}
const derivedAtom = atom(
(get) => get(countAtom),
(_get, _set, n: number) => {
store.add(n)
},
)
const Counter = () => {
const [count, add] = useAtom(derivedAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => add(1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 10')
fireEvent.click(getByText('button'))
await findByText('count: 11')
fireEvent.click(getByText('button'))
await findByText('count: 12')
})
it('create atom with onMount in async get', async () => {
const store = {
count: 10,
listeners: new Set<() => void>(),
add: (n: number) => {
store.count += n
store.listeners.forEach((listener) => listener())
},
}
const holderAtom = atom(async () => {
const countAtom = atom(1)
countAtom.onMount = (setCount) => {
const callback = () => {
setCount(store.count)
}
store.listeners.add(callback)
callback()
return () => store.listeners.delete(callback)
}
return countAtom
})
const derivedAtom = atom(
async (get) => get(await get(holderAtom)),
(_get, _set, n: number) => {
store.add(n)
},
)
const Counter = () => {
const [count, add] = useAtom(derivedAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => add(1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('count: 1')
await findByText('count: 10')
fireEvent.click(getByText('button'))
await findByText('count: 11')
fireEvent.click(getByText('button'))
await findByText('count: 12')
})
|
6,834 | 0 | petrpan-code/pmndrs/jotai/tests | petrpan-code/pmndrs/jotai/tests/react/optimization.test.tsx | import { useEffect } from 'react'
import { fireEvent, render, waitFor } from '@testing-library/react'
import { expect, it } from 'vitest'
import { useAtom } from 'jotai/react'
import { atom } from 'jotai/vanilla'
it('only relevant render function called (#156)', async () => {
const count1Atom = atom(0)
const count2Atom = atom(0)
let renderCount1 = 0
let renderCount2 = 0
const Counter1 = () => {
const [count, setCount] = useAtom(count1Atom)
++renderCount1
return (
<>
<div>count1: {count}</div>
<button onClick={() => setCount((c) => c + 1)}>button1</button>
</>
)
}
const Counter2 = () => {
const [count, setCount] = useAtom(count2Atom)
++renderCount2
return (
<>
<div>count2: {count}</div>
<button onClick={() => setCount((c) => c + 1)}>button2</button>
</>
)
}
const { getByText } = render(
<>
<Counter1 />
<Counter2 />
</>,
)
await waitFor(() => {
getByText('count1: 0')
getByText('count2: 0')
})
const renderCount1AfterMount = renderCount1
const renderCount2AfterMount = renderCount2
fireEvent.click(getByText('button1'))
await waitFor(() => {
getByText('count1: 1')
getByText('count2: 0')
})
expect(renderCount1).toBe(renderCount1AfterMount + 1)
expect(renderCount2).toBe(renderCount2AfterMount + 0)
fireEvent.click(getByText('button2'))
await waitFor(() => {
getByText('count1: 1')
getByText('count2: 1')
})
expect(renderCount1).toBe(renderCount1AfterMount + 1)
expect(renderCount2).toBe(renderCount2AfterMount + 1)
})
it('only render once using atoms with write-only atom', async () => {
const count1Atom = atom(0)
const count2Atom = atom(0)
const incrementAtom = atom(null, (_get, set, _arg) => {
set(count1Atom, (c) => c + 1)
set(count2Atom, (c) => c + 1)
})
let renderCount = 0
const Counter = () => {
const [count1] = useAtom(count1Atom)
const [count2] = useAtom(count2Atom)
++renderCount
return (
<div>
count1: {count1}, count2: {count2}
</div>
)
}
const Control = () => {
const [, increment] = useAtom(incrementAtom)
return <button onClick={increment}>button</button>
}
const { getByText, findByText } = render(
<>
<Counter />
<Control />
</>,
)
await findByText('count1: 0, count2: 0')
const renderCountAfterMount = renderCount
fireEvent.click(getByText('button'))
await findByText('count1: 1, count2: 1')
expect(renderCount).toBe(renderCountAfterMount + 1)
fireEvent.click(getByText('button'))
await findByText('count1: 2, count2: 2')
expect(renderCount).toBe(renderCountAfterMount + 2)
})
it('useless re-renders with static atoms (#355)', async () => {
// check out https://codesandbox.io/s/m82r5 to see the expected re-renders
const countAtom = atom(0)
const unrelatedAtom = atom(0)
let renderCount = 0
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
useAtom(unrelatedAtom)
++renderCount
return (
<>
<div>count: {count}</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<>
<Counter />
</>,
)
await findByText('count: 0')
const renderCountAfterMount = renderCount
fireEvent.click(getByText('button'))
await findByText('count: 1')
expect(renderCount).toBe(renderCountAfterMount + 1)
fireEvent.click(getByText('button'))
await findByText('count: 2')
expect(renderCount).toBe(renderCountAfterMount + 2)
})
it('does not re-render if value is the same (#1158)', async () => {
const countAtom = atom(0)
let renderCount = 0
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
++renderCount
return (
<>
<div>count: {count}</div>
<button onClick={() => setCount((c) => c)}>noop</button>
<button onClick={() => setCount((c) => c + 1)}>inc</button>
</>
)
}
const { getByText, findByText } = render(
<>
<Counter />
</>,
)
await findByText('count: 0')
const renderCountAfterMount = renderCount
fireEvent.click(getByText('noop'))
await findByText('count: 0')
expect(renderCount).toBe(renderCountAfterMount + 0)
fireEvent.click(getByText('inc'))
await findByText('count: 1')
expect(renderCount).toBe(renderCountAfterMount + 1)
fireEvent.click(getByText('noop'))
await findByText('count: 1')
expect(renderCount).toBe(renderCountAfterMount + 1)
fireEvent.click(getByText('inc'))
await findByText('count: 2')
expect(renderCount).toBe(renderCountAfterMount + 2)
})
it('no extra rerenders after commit with derived atoms (#1213)', async () => {
const baseAtom = atom({ count1: 0, count2: 0 })
const count1Atom = atom((get) => get(baseAtom).count1)
const count2Atom = atom((get) => get(baseAtom).count2)
let renderCount1 = 0
let renderCount1AfterCommit = 0
const Counter1 = () => {
const [count1] = useAtom(count1Atom)
++renderCount1
useEffect(() => {
renderCount1AfterCommit = renderCount1
})
return <div>count1: {count1}</div>
}
let renderCount2 = 0
let renderCount2AfterCommit = 0
const Counter2 = () => {
const [count2] = useAtom(count2Atom)
++renderCount2
useEffect(() => {
renderCount2AfterCommit = renderCount2
})
return <div>count2: {count2}</div>
}
const Control = () => {
const [, setValue] = useAtom(baseAtom)
const inc1 = () => {
setValue((prev) => ({ ...prev, count1: prev.count1 + 1 }))
}
const inc2 = () => {
setValue((prev) => ({ ...prev, count2: prev.count2 + 1 }))
}
return (
<div>
<button onClick={inc1}>inc1</button>
<button onClick={inc2}>inc2</button>
</div>
)
}
const { getByText } = render(
<>
<Counter1 />
<Counter2 />
<Control />
</>,
)
await waitFor(() => {
getByText('count1: 0')
getByText('count2: 0')
})
expect(renderCount1 > 0).toBeTruthy()
expect(renderCount2 > 0).toBeTruthy()
fireEvent.click(getByText('inc1'))
await waitFor(() => {
getByText('count1: 1')
getByText('count2: 0')
})
expect(renderCount1).toBe(renderCount1AfterCommit)
fireEvent.click(getByText('inc2'))
await waitFor(() => {
getByText('count1: 1')
getByText('count2: 1')
})
expect(renderCount2).toBe(renderCount2AfterCommit)
fireEvent.click(getByText('inc1'))
await waitFor(() => {
getByText('count1: 2')
getByText('count2: 1')
})
expect(renderCount1).toBe(renderCount1AfterCommit)
})
|
6,835 | 0 | petrpan-code/pmndrs/jotai/tests | petrpan-code/pmndrs/jotai/tests/react/provider.test.tsx | import { StrictMode } from 'react'
import { render, waitFor } from '@testing-library/react'
import { it } from 'vitest'
import { Provider, useAtom } from 'jotai/react'
import { atom, createStore } from 'jotai/vanilla'
it('uses initial values from provider', async () => {
const countAtom = atom(1)
const petAtom = atom('cat')
const Display = () => {
const [count] = useAtom(countAtom)
const [pet] = useAtom(petAtom)
return (
<>
<p>count: {count}</p>
<p>pet: {pet}</p>
</>
)
}
const store = createStore()
store.set(countAtom, 0)
store.set(petAtom, 'dog')
const { getByText } = render(
<StrictMode>
<Provider store={store}>
<Display />
</Provider>
</StrictMode>,
)
await waitFor(() => {
getByText('count: 0')
getByText('pet: dog')
})
})
it('only uses initial value from provider for specific atom', async () => {
const countAtom = atom(1)
const petAtom = atom('cat')
const Display = () => {
const [count] = useAtom(countAtom)
const [pet] = useAtom(petAtom)
return (
<>
<p>count: {count}</p>
<p>pet: {pet}</p>
</>
)
}
const store = createStore()
store.set(petAtom, 'dog')
const { getByText } = render(
<StrictMode>
<Provider store={store}>
<Display />
</Provider>
</StrictMode>,
)
await waitFor(() => {
getByText('count: 1')
getByText('pet: dog')
})
})
it('renders correctly without children', () => {
render(
<StrictMode>
<Provider />
</StrictMode>,
)
})
|
6,836 | 0 | petrpan-code/pmndrs/jotai/tests | petrpan-code/pmndrs/jotai/tests/react/transition.test.tsx | /// <reference types="react/experimental" />
import ReactExports, { StrictMode, Suspense, useEffect } from 'react'
import { act, render, waitFor } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import { describe, expect, it } from 'vitest'
import { useAtom, useAtomValue, useSetAtom } from 'jotai/react'
import { atom } from 'jotai/vanilla'
const { use, useTransition } = ReactExports
describe.skipIf(typeof useTransition !== 'function')('useTransition', () => {
// FIXME some tests are failing with react@experimental
it.skipIf(typeof use === 'function')(
'no extra commit with useTransition (#1125)',
async () => {
const countAtom = atom(0)
let resolve = () => {}
const delayedAtom = atom(async (get) => {
await new Promise<void>((r) => (resolve = r))
return get(countAtom)
})
const commited: { pending: boolean; delayed: number }[] = []
const Counter = () => {
const setCount = useSetAtom(countAtom)
const delayed = useAtomValue(delayedAtom)
const [pending, startTransition] = useTransition()
useEffect(() => {
commited.push({ pending, delayed })
})
return (
<>
<div>delayed: {delayed}</div>
<button
onClick={() => startTransition(() => setCount((c) => c + 1))}
>
button
</button>
</>
)
}
const { getByText } = render(
<>
<Suspense fallback="loading">
<Counter />
</Suspense>
</>,
)
resolve()
await waitFor(() => expect(getByText('delayed: 0')).toBeTruthy())
await userEvent.click(getByText('button'))
act(() => {
resolve()
})
await waitFor(() => expect(getByText('delayed: 1')).toBeTruthy())
expect(commited).toEqual([
{ pending: false, delayed: 0 },
{ pending: true, delayed: 0 },
{ pending: false, delayed: 1 },
])
},
)
it('can update normal atom with useTransition (#1151)', async () => {
const countAtom = atom(0)
const toggleAtom = atom(false)
const pendingAtom = atom((get) => {
if (get(toggleAtom)) {
return new Promise(() => {})
}
return false
})
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
const toggle = useSetAtom(toggleAtom)
useAtomValue(pendingAtom)
const [pending, startTransition] = useTransition()
return (
<>
<div>count: {count}</div>
<button onClick={() => setCount((c) => c + 1)}>increment</button>
{pending && 'pending'}
<button onClick={() => startTransition(() => toggle((x) => !x))}>
toggle
</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('count: 0')
await userEvent.click(getByText('toggle'))
await waitFor(() => expect(findByText('pending')).toBeTruthy())
await userEvent.click(getByText('increment'))
await waitFor(() => expect(findByText('count: 1')).toBeTruthy())
await userEvent.click(getByText('increment'))
await waitFor(() => expect(findByText('count: 2')).toBeTruthy())
})
})
|
6,837 | 0 | petrpan-code/pmndrs/jotai/tests | petrpan-code/pmndrs/jotai/tests/react/types.test.tsx | import { expectType } from 'ts-expect'
import { it } from 'vitest'
import { useAtom } from 'jotai/react'
import { atom } from 'jotai/vanilla'
it('useAtom should return the correct types', () => {
function Component() {
// primitive atom
const primitiveAtom = atom(0)
expectType<[number, (arg: number) => void]>(useAtom(primitiveAtom))
// read-only derived atom
const readonlyDerivedAtom = atom((get) => get(primitiveAtom) * 2)
expectType<[number, (arg: number) => void]>(useAtom(readonlyDerivedAtom))
// read-write derived atom
const readWriteDerivedAtom = atom(
(get) => get(primitiveAtom),
(get, set, value: number) => {
set(primitiveAtom, get(primitiveAtom) + value)
},
)
expectType<[number, (arg: number) => void]>(useAtom(readWriteDerivedAtom))
// write-only derived atom
const writeonlyDerivedAtom = atom(null, (get, set) => {
set(primitiveAtom, get(primitiveAtom) - 1)
})
expectType<[null, (arg: number) => void]>(useAtom(writeonlyDerivedAtom))
}
Component
})
it('useAtom should handle inference of atoms (#1831 #1387)', () => {
const fieldAtoms = {
username: atom(''),
age: atom(0),
checked: atom(false),
}
const useField = <T extends keyof typeof fieldAtoms>(prop: T) => {
return useAtom(fieldAtoms[prop])
}
function Component() {
expectType<[string, (arg: string) => void]>(useField('username'))
expectType<[number, (arg: number) => void]>(useField('age'))
expectType<[boolean, (arg: boolean) => void]>(useField('checked'))
}
Component
})
|
6,838 | 0 | petrpan-code/pmndrs/jotai/tests | petrpan-code/pmndrs/jotai/tests/react/useAtomValue.test.tsx | import { StrictMode } from 'react'
import { fireEvent, render } from '@testing-library/react'
import { it } from 'vitest'
import { useAtomValue, useSetAtom } from 'jotai/react'
import { atom } from 'jotai/vanilla'
it('useAtomValue basic test', async () => {
const countAtom = atom(0)
const Counter = () => {
const count = useAtomValue(countAtom)
const setCount = useSetAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => setCount(count + 1)}>dispatch</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('dispatch'))
await findByText('count: 1')
})
|
6,839 | 0 | petrpan-code/pmndrs/jotai/tests | petrpan-code/pmndrs/jotai/tests/react/useSetAtom.test.tsx | import { StrictMode, useEffect, useRef } from 'react'
import type { PropsWithChildren } from 'react'
import { fireEvent, render, waitFor } from '@testing-library/react'
import { it } from 'vitest'
import { useAtomValue, useSetAtom } from 'jotai/react'
import { atom } from 'jotai/vanilla'
const useCommitCount = () => {
const commitCountRef = useRef(1)
useEffect(() => {
commitCountRef.current += 1
})
return commitCountRef.current
}
it('useSetAtom does not trigger rerender in component', async () => {
const countAtom = atom(0)
const Displayer = () => {
const count = useAtomValue(countAtom)
const commits = useCommitCount()
return (
<div>
count: {count}, commits: {commits}
</div>
)
}
const Updater = () => {
const setCount = useSetAtom(countAtom)
const commits = useCommitCount()
return (
<>
<button onClick={() => setCount((value) => value + 1)}>
increment
</button>
<div>updater commits: {commits}</div>
</>
)
}
const Parent = () => {
return (
<>
<Displayer />
<Updater />
</>
)
}
const { getByText } = render(
<>
<Parent />
</>,
)
await waitFor(() => {
getByText('count: 0, commits: 1')
getByText('updater commits: 1')
})
fireEvent.click(getByText('increment'))
await waitFor(() => {
getByText('count: 1, commits: 2')
getByText('updater commits: 1')
})
fireEvent.click(getByText('increment'))
await waitFor(() => {
getByText('count: 2, commits: 3')
getByText('updater commits: 1')
})
fireEvent.click(getByText('increment'))
await waitFor(() => {
getByText('count: 3, commits: 4')
getByText('updater commits: 1')
})
})
it('useSetAtom with write without an argument', async () => {
const countAtom = atom(0)
const incrementCountAtom = atom(null, (get, set) =>
set(countAtom, get(countAtom) + 1),
)
const Button = ({ cb, children }: PropsWithChildren<{ cb: () => void }>) => (
<button onClick={cb}>{children}</button>
)
const Displayer = () => {
const count = useAtomValue(countAtom)
return <div>count: {count}</div>
}
const Updater = () => {
const setCount = useSetAtom(incrementCountAtom)
return <Button cb={setCount}>increment</Button>
}
const Parent = () => {
return (
<>
<Displayer />
<Updater />
</>
)
}
const { getByText } = render(
<StrictMode>
<Parent />
</StrictMode>,
)
await waitFor(() => {
getByText('count: 0')
})
fireEvent.click(getByText('increment'))
await waitFor(() => {
getByText('count: 1')
})
})
|
6,840 | 0 | petrpan-code/pmndrs/jotai/tests/react | petrpan-code/pmndrs/jotai/tests/react/utils/types.test.tsx | import { it } from 'vitest'
import { useHydrateAtoms } from 'jotai/react/utils'
import { atom } from 'jotai/vanilla'
it('useHydrateAtoms should not allow invalid atom types when array is passed', () => {
function Component() {
const countAtom = atom(0)
const activeAtom = atom(true)
// Adding @ts-ignore for typescript 3.8 support
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
// @ts-expect-error TS2769
useHydrateAtoms([
[countAtom, 'foo'],
[activeAtom, 0],
])
// Adding @ts-ignore for typescript 3.8 support
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
// @ts-expect-error TS2769
useHydrateAtoms([
[countAtom, 1],
[activeAtom, 0],
])
// Adding @ts-ignore for typescript 3.8 support
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
// @ts-expect-error TS2769
useHydrateAtoms([
[countAtom, true],
[activeAtom, false],
])
}
Component
})
|
6,841 | 0 | petrpan-code/pmndrs/jotai/tests/react | petrpan-code/pmndrs/jotai/tests/react/utils/useAtomCallback.test.tsx | import { StrictMode, useCallback, useEffect, useState } from 'react'
import { fireEvent, render, waitFor } from '@testing-library/react'
import { it } from 'vitest'
import { useAtom } from 'jotai/react'
import { useAtomCallback } from 'jotai/react/utils'
import { atom } from 'jotai/vanilla'
it('useAtomCallback with get', async () => {
const countAtom = atom(0)
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
return (
<>
<div>atom count: {count}</div>
<button onClick={() => setCount((c) => c + 1)}>dispatch</button>
</>
)
}
const Monitor = () => {
const [count, setCount] = useState(0)
const readCount = useAtomCallback(
useCallback((get) => {
const currentCount = get(countAtom)
setCount(currentCount)
return currentCount
}, []),
)
useEffect(() => {
const timer = setInterval(() => {
readCount()
}, 10)
return () => {
clearInterval(timer)
}
}, [readCount])
return (
<>
<div>state count: {count}</div>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Counter />
<Monitor />
</StrictMode>,
)
await findByText('atom count: 0')
fireEvent.click(getByText('dispatch'))
await waitFor(() => {
getByText('atom count: 1')
getByText('state count: 1')
})
})
it('useAtomCallback with set and update', async () => {
const countAtom = atom(0)
const changeableAtom = atom(0)
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => setCount((c) => c + 1)}>dispatch</button>
</>
)
}
const Monitor = () => {
const [changeableCount] = useAtom(changeableAtom)
const changeCount = useAtomCallback(
useCallback((get, set) => {
const currentCount = get(countAtom)
set(changeableAtom, currentCount)
return currentCount
}, []),
)
useEffect(() => {
const timer = setInterval(() => {
changeCount()
}, 10)
return () => {
clearInterval(timer)
}
}, [changeCount])
return (
<>
<div>changeable count: {changeableCount}</div>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Counter />
<Monitor />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('dispatch'))
await waitFor(() => {
getByText('count: 1')
getByText('changeable count: 1')
})
})
it('useAtomCallback with set and update and arg', async () => {
const countAtom = atom(0)
const App = () => {
const [count] = useAtom(countAtom)
const setCount = useAtomCallback(
useCallback((_get, set, arg: number) => {
set(countAtom, arg)
return arg
}, []),
)
return (
<div>
<p>count: {count}</p>
<button onClick={() => setCount(42)}>dispatch</button>
</div>
)
}
const { findByText, getByText } = render(
<StrictMode>
<App />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('dispatch'))
await waitFor(() => {
getByText('count: 42')
})
})
it('useAtomCallback with sync atom (#1100)', async () => {
const countAtom = atom(0)
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
const readCount = useAtomCallback(useCallback((get) => get(countAtom), []))
useEffect(() => {
const promiseOrValue = readCount()
if (typeof promiseOrValue !== 'number') {
throw new Error('should return number')
}
}, [readCount])
return (
<>
<div>atom count: {count}</div>
<button onClick={() => setCount((c) => c + 1)}>dispatch</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('atom count: 0')
fireEvent.click(getByText('dispatch'))
await findByText('atom count: 1')
})
|
6,842 | 0 | petrpan-code/pmndrs/jotai/tests/react | petrpan-code/pmndrs/jotai/tests/react/utils/useHydrateAtoms.test.tsx | import { StrictMode, useEffect, useRef } from 'react'
import { fireEvent, render } from '@testing-library/react'
import { expect, it, vi } from 'vitest'
import { useAtom, useAtomValue } from 'jotai/react'
import { useHydrateAtoms } from 'jotai/react/utils'
import { atom } from 'jotai/vanilla'
it('useHydrateAtoms should only hydrate on first render', async () => {
const countAtom = atom(0)
const statusAtom = atom('fulfilled')
const Counter = ({
initialCount,
initialStatus,
}: {
initialCount: number
initialStatus: string
}) => {
useHydrateAtoms([
[countAtom, initialCount],
[statusAtom, initialStatus],
])
const [countValue, setCount] = useAtom(countAtom)
const [statusValue, setStatus] = useAtom(statusAtom)
return (
<>
<div>count: {countValue}</div>
<button onClick={() => setCount((count) => count + 1)}>dispatch</button>
<div>status: {statusValue}</div>
<button
onClick={() =>
setStatus((status) =>
status === 'fulfilled' ? 'rejected' : 'fulfilled',
)
}
>
update
</button>
</>
)
}
const { findByText, getByText, rerender } = render(
<StrictMode>
<Counter initialCount={42} initialStatus="rejected" />
</StrictMode>,
)
await findByText('count: 42')
await findByText('status: rejected')
fireEvent.click(getByText('dispatch'))
fireEvent.click(getByText('update'))
await findByText('count: 43')
await findByText('status: fulfilled')
rerender(
<StrictMode>
<Counter initialCount={65} initialStatus="rejected" />
</StrictMode>,
)
await findByText('count: 43')
await findByText('status: fulfilled')
})
it('useHydrateAtoms should only hydrate on first render using a Map', async () => {
const countAtom = atom(0)
const activeAtom = atom(true)
const Counter = ({
initialActive = false,
initialCount,
}: {
initialActive?: boolean
initialCount: number
}) => {
useHydrateAtoms(
new Map<
typeof activeAtom | typeof countAtom,
typeof initialActive | typeof initialCount
>([
[activeAtom, initialActive],
[countAtom, initialCount],
]),
)
const activeValue = useAtomValue(activeAtom)
const [countValue, setCount] = useAtom(countAtom)
return (
<>
<div>is active: {activeValue ? 'yes' : 'no'}</div>
<div>count: {countValue}</div>
<button onClick={() => setCount((count) => count + 1)}>dispatch</button>
</>
)
}
const { findByText, getByText, rerender } = render(
<StrictMode>
<Counter initialCount={42} />
</StrictMode>,
)
await findByText('count: 42')
await findByText('is active: no')
fireEvent.click(getByText('dispatch'))
await findByText('count: 43')
rerender(
<StrictMode>
<Counter initialCount={65} initialActive={true} />
</StrictMode>,
)
await findByText('count: 43')
await findByText('is active: no')
})
it('useHydrateAtoms should not trigger unnecessary re-renders', async () => {
const countAtom = atom(0)
const Counter = ({ initialCount }: { initialCount: number }) => {
useHydrateAtoms([[countAtom, initialCount]])
const [countValue, setCount] = useAtom(countAtom)
const commitCount = useRef(1)
useEffect(() => {
++commitCount.current
})
return (
<>
<div>commits: {commitCount.current}</div>
<div>count: {countValue}</div>
<button onClick={() => setCount((count) => count + 1)}>dispatch</button>
</>
)
}
const { findByText, getByText } = render(
<>
<Counter initialCount={42} />
</>,
)
await findByText('count: 42')
await findByText('commits: 1')
fireEvent.click(getByText('dispatch'))
await findByText('count: 43')
await findByText('commits: 2')
})
it('useHydrateAtoms should work with derived atoms', async () => {
const countAtom = atom(0)
const doubleAtom = atom((get) => get(countAtom) * 2)
const Counter = ({ initialCount }: { initialCount: number }) => {
useHydrateAtoms([[countAtom, initialCount]])
const [countValue, setCount] = useAtom(countAtom)
const [doubleCount] = useAtom(doubleAtom)
return (
<>
<div>count: {countValue}</div>
<div>doubleCount: {doubleCount}</div>
<button onClick={() => setCount((count) => count + 1)}>dispatch</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Counter initialCount={42} />
</StrictMode>,
)
await findByText('count: 42')
await findByText('doubleCount: 84')
fireEvent.click(getByText('dispatch'))
await findByText('count: 43')
await findByText('doubleCount: 86')
})
it('useHydrateAtoms can only restore an atom once', async () => {
const countAtom = atom(0)
const Counter = ({ initialCount }: { initialCount: number }) => {
useHydrateAtoms([[countAtom, initialCount]])
const [countValue, setCount] = useAtom(countAtom)
return (
<>
<div>count: {countValue}</div>
<button onClick={() => setCount((count) => count + 1)}>dispatch</button>
</>
)
}
const Counter2 = ({ count }: { count: number }) => {
useHydrateAtoms([[countAtom, count]])
const [countValue, setCount] = useAtom(countAtom)
return (
<>
<div>count: {countValue}</div>
<button onClick={() => setCount((count) => count + 1)}>dispatch</button>
</>
)
}
const { findByText, getByText, rerender } = render(
<StrictMode>
<Counter initialCount={42} />
</StrictMode>,
)
await findByText('count: 42')
fireEvent.click(getByText('dispatch'))
await findByText('count: 43')
rerender(
<StrictMode>
<Counter2 count={65} />
</StrictMode>,
)
await findByText('count: 43')
fireEvent.click(getByText('dispatch'))
await findByText('count: 44')
})
it('useHydrateAtoms should respect onMount', async () => {
const countAtom = atom(0)
const onMountFn = vi.fn(() => {})
countAtom.onMount = onMountFn
const Counter = ({ initialCount }: { initialCount: number }) => {
useHydrateAtoms([[countAtom, initialCount]])
const [countValue] = useAtom(countAtom)
return <div>count: {countValue}</div>
}
const { findByText } = render(
<>
<Counter initialCount={42} />
</>,
)
await findByText('count: 42')
expect(onMountFn).toHaveBeenCalledTimes(1)
})
it('passing dangerouslyForceHydrate to useHydrateAtoms will re-hydrated atoms', async () => {
const countAtom = atom(0)
const statusAtom = atom('fulfilled')
const Counter = ({
initialCount,
initialStatus,
dangerouslyForceHydrate = false,
}: {
initialCount: number
initialStatus: string
dangerouslyForceHydrate?: boolean
}) => {
useHydrateAtoms(
[
[countAtom, initialCount],
[statusAtom, initialStatus],
],
{
dangerouslyForceHydrate,
},
)
const [countValue, setCount] = useAtom(countAtom)
const [statusValue, setStatus] = useAtom(statusAtom)
return (
<>
<div>count: {countValue}</div>
<button onClick={() => setCount((count) => count + 1)}>dispatch</button>
<div>status: {statusValue}</div>
<button
onClick={() =>
setStatus((status) =>
status === 'fulfilled' ? 'rejected' : 'fulfilled',
)
}
>
update
</button>
</>
)
}
const { findByText, getByText, rerender } = render(
<StrictMode>
<Counter initialCount={42} initialStatus="rejected" />
</StrictMode>,
)
await findByText('count: 42')
await findByText('status: rejected')
fireEvent.click(getByText('dispatch'))
fireEvent.click(getByText('update'))
await findByText('count: 43')
await findByText('status: fulfilled')
rerender(
<StrictMode>
<Counter initialCount={65} initialStatus="rejected" />
</StrictMode>,
)
await findByText('count: 43')
await findByText('status: fulfilled')
rerender(
<StrictMode>
<Counter
initialCount={11}
initialStatus="rejected"
dangerouslyForceHydrate={true}
/>
</StrictMode>,
)
await findByText('count: 11')
await findByText('status: rejected')
})
|
6,843 | 0 | petrpan-code/pmndrs/jotai/tests/react | petrpan-code/pmndrs/jotai/tests/react/utils/useReducerAtom.test.tsx | import { StrictMode } from 'react'
import { fireEvent, render } from '@testing-library/react'
import { it } from 'vitest'
import { useReducerAtom } from 'jotai/react/utils'
import { atom } from 'jotai/vanilla'
it('useReducerAtom with no action argument', async () => {
const countAtom = atom(0)
const reducer = (state: number) => state + 2
const Parent = () => {
const [count, dispatch] = useReducerAtom(countAtom, reducer)
return (
<>
<div>count: {count}</div>
<button onClick={() => dispatch()}>dispatch</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Parent />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('dispatch'))
await findByText('count: 2')
fireEvent.click(getByText('dispatch'))
await findByText('count: 4')
})
it('useReducerAtom with optional action argument', async () => {
const countAtom = atom(0)
const reducer = (state: number, action?: 'INCREASE' | 'DECREASE') => {
switch (action) {
case 'INCREASE':
return state + 1
case 'DECREASE':
return state - 1
case undefined:
return state
}
}
const Parent = () => {
const [count, dispatch] = useReducerAtom(countAtom, reducer)
return (
<>
<div>count: {count}</div>
<button onClick={() => dispatch('INCREASE')}>dispatch INCREASE</button>
<button onClick={() => dispatch('DECREASE')}>dispatch DECREASE</button>
<button onClick={() => dispatch()}>dispatch empty</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Parent />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('dispatch INCREASE'))
await findByText('count: 1')
fireEvent.click(getByText('dispatch empty'))
await findByText('count: 1')
fireEvent.click(getByText('dispatch DECREASE'))
await findByText('count: 0')
})
it('useReducerAtom with non-optional action argument', async () => {
const countAtom = atom(0)
const reducer = (state: number, action: 'INCREASE' | 'DECREASE') => {
switch (action) {
case 'INCREASE':
return state + 1
case 'DECREASE':
return state - 1
}
}
const Parent = () => {
const [count, dispatch] = useReducerAtom(countAtom, reducer)
return (
<>
<div>count: {count}</div>
<button onClick={() => dispatch('INCREASE')}>dispatch INCREASE</button>
<button onClick={() => dispatch('DECREASE')}>dispatch DECREASE</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Parent />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('dispatch INCREASE'))
await findByText('count: 1')
fireEvent.click(getByText('dispatch DECREASE'))
await findByText('count: 0')
})
|
6,844 | 0 | petrpan-code/pmndrs/jotai/tests/react | petrpan-code/pmndrs/jotai/tests/react/utils/useResetAtom.test.tsx | import { StrictMode } from 'react'
import { fireEvent, render } from '@testing-library/react'
import { it } from 'vitest'
import { useAtom } from 'jotai/react'
import { useResetAtom } from 'jotai/react/utils'
import { atom } from 'jotai/vanilla'
import { RESET, atomWithReducer, atomWithReset } from 'jotai/vanilla/utils'
it('atomWithReset resets to its first value', async () => {
const countAtom = atomWithReset(0)
const Parent = () => {
const [count, setValue] = useAtom(countAtom)
const resetAtom = useResetAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={resetAtom}>reset</button>
<button onClick={() => setValue((oldValue) => oldValue + 1)}>
increment
</button>
<button onClick={() => setValue(10)}>set to 10</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Parent />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('increment'))
await findByText('count: 1')
fireEvent.click(getByText('increment'))
await findByText('count: 2')
fireEvent.click(getByText('increment'))
await findByText('count: 3')
fireEvent.click(getByText('reset'))
await findByText('count: 0')
fireEvent.click(getByText('set to 10'))
await findByText('count: 10')
fireEvent.click(getByText('increment'))
await findByText('count: 11')
fireEvent.click(getByText('increment'))
await findByText('count: 12')
fireEvent.click(getByText('increment'))
await findByText('count: 13')
})
it('atomWithReset reset based on previous value', async () => {
const countAtom = atomWithReset(0)
const Parent = () => {
const [count, setValue] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button
onClick={() =>
setValue((oldValue) => (oldValue === 3 ? RESET : oldValue + 1))
}
>
increment till 3, then reset
</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Parent />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('increment till 3, then reset'))
await findByText('count: 1')
fireEvent.click(getByText('increment till 3, then reset'))
await findByText('count: 2')
fireEvent.click(getByText('increment till 3, then reset'))
await findByText('count: 3')
fireEvent.click(getByText('increment till 3, then reset'))
await findByText('count: 0')
})
it('atomWithReset through read-write atom', async () => {
const primitiveAtom = atomWithReset(0)
const countAtom = atom(
(get) => get(primitiveAtom),
(_get, set, newValue: number | typeof RESET) =>
set(primitiveAtom, newValue),
)
const Parent = () => {
const [count, setValue] = useAtom(countAtom)
const resetAtom = useResetAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={resetAtom}>reset</button>
<button onClick={() => setValue(10)}>set to 10</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Parent />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('set to 10'))
await findByText('count: 10')
fireEvent.click(getByText('reset'))
await findByText('count: 0')
})
it('useResetAtom with custom atom', async () => {
const reducer = (state: number, action: 'INCREASE' | typeof RESET) => {
switch (action) {
case 'INCREASE':
return state + 1
case RESET:
return 0
}
}
const countAtom = atomWithReducer(0, reducer)
const Parent = () => {
const [count, dispatch] = useAtom(countAtom)
const resetAtom = useResetAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={resetAtom}>reset</button>
<button onClick={() => dispatch('INCREASE')}>increment</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Parent />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('increment'))
await findByText('count: 1')
fireEvent.click(getByText('increment'))
await findByText('count: 2')
fireEvent.click(getByText('increment'))
await findByText('count: 3')
fireEvent.click(getByText('reset'))
await findByText('count: 0')
})
|
6,845 | 0 | petrpan-code/pmndrs/jotai/tests/react | petrpan-code/pmndrs/jotai/tests/react/vanilla-utils/atomFamily.test.tsx | import { StrictMode, Suspense, useState } from 'react'
import { fireEvent, render, waitFor } from '@testing-library/react'
import { expect, it } from 'vitest'
import { useAtom, useSetAtom } from 'jotai/react'
import { atom } from 'jotai/vanilla'
import type { SetStateAction, WritableAtom } from 'jotai/vanilla'
import { atomFamily } from 'jotai/vanilla/utils'
it('new atomFamily impl', async () => {
const myFamily = atomFamily((param: string) => atom(param))
const Displayer = ({ index }: { index: string }) => {
const [count] = useAtom(myFamily(index))
return <div>count: {count}</div>
}
const { findByText } = render(
<StrictMode>
<Displayer index={'a'} />
</StrictMode>,
)
await findByText('count: a')
})
it('primitive atomFamily returns same reference for same parameters', async () => {
const myFamily = atomFamily((num: number) => atom({ num }))
expect(myFamily(0)).toEqual(myFamily(0))
expect(myFamily(0)).not.toEqual(myFamily(1))
expect(myFamily(1)).not.toEqual(myFamily(0))
})
it('read-only derived atomFamily returns same reference for same parameters', async () => {
const arrayAtom = atom([0])
const myFamily = atomFamily((num: number) =>
atom((get) => get(arrayAtom)[num] as number),
)
expect(myFamily(0)).toEqual(myFamily(0))
expect(myFamily(0)).not.toEqual(myFamily(1))
expect(myFamily(1)).not.toEqual(myFamily(0))
})
it('removed atom creates a new reference', async () => {
const bigAtom = atom([0])
const myFamily = atomFamily((num: number) =>
atom((get) => get(bigAtom)[num] as number),
)
const savedReference = myFamily(0)
expect(savedReference).toEqual(myFamily(0))
myFamily.remove(0)
const newReference = myFamily(0)
expect(savedReference).not.toEqual(newReference)
myFamily.remove(1337)
expect(myFamily(0)).toEqual(newReference)
})
it('primitive atomFamily initialized with props', async () => {
const myFamily = atomFamily((param: number) => atom(param))
const Displayer = ({ index }: { index: number }) => {
const [count, setCount] = useAtom(myFamily(index))
return (
<div>
count: {count}
<button onClick={() => setCount((c) => c + 10)}>button</button>
</div>
)
}
const Parent = () => {
const [index, setIndex] = useState(1)
return (
<div>
<button onClick={() => setIndex((i) => i + 1)}>increment</button>
<Displayer index={index} />
</div>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Parent />
</StrictMode>,
)
await findByText('count: 1')
fireEvent.click(getByText('button'))
await findByText('count: 11')
fireEvent.click(getByText('increment'))
await findByText('count: 2')
fireEvent.click(getByText('button'))
await findByText('count: 12')
})
it('derived atomFamily functionality as usual', async () => {
const arrayAtom = atom([0, 0, 0])
const myFamily = atomFamily((param: number) =>
atom(
(get) => get(arrayAtom)[param] as number,
(_, set, update) => {
set(arrayAtom, (oldArray) => {
if (typeof oldArray[param] === 'undefined') return oldArray
const newValue =
typeof update === 'function'
? update(oldArray[param] as number)
: update
const newArray = [
...oldArray.slice(0, param),
newValue,
...oldArray.slice(param + 1),
]
return newArray
})
},
),
)
const Displayer = ({
index,
countAtom,
}: {
index: number
countAtom: WritableAtom<number, [SetStateAction<number>], void>
}) => {
const [count, setCount] = useAtom(countAtom)
return (
<div>
index: {index}, count: {count}
<button onClick={() => setCount((oldValue) => oldValue + 1)}>
increment #{index}
</button>
</div>
)
}
const indicesAtom = atom((get) => [...new Array(get(arrayAtom).length)])
const Parent = () => {
const [indices] = useAtom(indicesAtom)
return (
<div>
{indices.map((_, index) => (
<Displayer key={index} index={index} countAtom={myFamily(index)} />
))}
</div>
)
}
const { getByText } = render(
<StrictMode>
<Parent />
</StrictMode>,
)
await waitFor(() => {
getByText('index: 0, count: 0')
getByText('index: 1, count: 0')
getByText('index: 2, count: 0')
})
fireEvent.click(getByText('increment #1'))
await waitFor(() => {
getByText('index: 0, count: 0')
getByText('index: 1, count: 1')
getByText('index: 2, count: 0')
})
fireEvent.click(getByText('increment #0'))
await waitFor(() => {
getByText('index: 0, count: 1')
getByText('index: 1, count: 1')
getByText('index: 2, count: 0')
})
fireEvent.click(getByText('increment #2'))
await waitFor(() => {
getByText('index: 0, count: 1')
getByText('index: 1, count: 1')
getByText('index: 2, count: 1')
})
})
it('custom equality function work', async () => {
const bigAtom = atom([0])
const badFamily = atomFamily((num: { index: number }) =>
atom((get) => get(bigAtom)[num.index] as number),
)
const goodFamily = atomFamily(
(num: { index: number }) =>
atom((get) => get(bigAtom)[num.index] as number),
(l, r) => l.index === r.index,
)
expect(badFamily({ index: 0 })).not.toEqual(badFamily({ index: 0 }))
expect(badFamily({ index: 0 })).not.toEqual(badFamily({ index: 0 }))
expect(goodFamily({ index: 0 })).toEqual(goodFamily({ index: 0 }))
expect(goodFamily({ index: 0 })).not.toEqual(goodFamily({ index: 1 }))
})
it('a derived atom from an async atomFamily (#351)', async () => {
const countAtom = atom(1)
const resolve: (() => void)[] = []
const getAsyncAtom = atomFamily((n: number) =>
atom(async () => {
await new Promise<void>((r) => resolve.push(r))
return n + 10
}),
)
const derivedAtom = atom((get) => get(getAsyncAtom(get(countAtom))))
const Counter = () => {
const setCount = useSetAtom(countAtom)
const [derived] = useAtom(derivedAtom)
return (
<>
<div>derived: {derived}</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('loading')
resolve.splice(0).forEach((fn) => fn())
await findByText('derived: 11')
fireEvent.click(getByText('button'))
await findByText('loading')
resolve.splice(0).forEach((fn) => fn())
await findByText('derived: 12')
fireEvent.click(getByText('button'))
await findByText('loading')
resolve.splice(0).forEach((fn) => fn())
await findByText('derived: 13')
})
it('setShouldRemove with custom equality function', async () => {
const myFamily = atomFamily(
(num: { index: number }) => atom(num),
(l, r) => l.index === r.index,
)
let firstTime = true
myFamily.setShouldRemove(() => {
if (firstTime) {
firstTime = false
return true
}
return false
})
const family1 = myFamily({ index: 0 })
const family2 = myFamily({ index: 0 })
const family3 = myFamily({ index: 0 })
expect(family1).not.toBe(family2)
expect(family2).toBe(family3)
})
|
6,846 | 0 | petrpan-code/pmndrs/jotai/tests/react | petrpan-code/pmndrs/jotai/tests/react/vanilla-utils/atomWithDefault.test.tsx | import { StrictMode, Suspense } from 'react'
import { fireEvent, render, waitFor } from '@testing-library/react'
import { it } from 'vitest'
import { useAtom } from 'jotai/react'
import { atom } from 'jotai/vanilla'
import { RESET, atomWithDefault } from 'jotai/vanilla/utils'
it('simple sync get default', async () => {
const count1Atom = atom(1)
const count2Atom = atomWithDefault((get) => get(count1Atom) * 2)
const Counter = () => {
const [count1, setCount1] = useAtom(count1Atom)
const [count2, setCount2] = useAtom(count2Atom)
return (
<>
<div>
count1: {count1}, count2: {count2}
</div>
<button onClick={() => setCount1((c) => c + 1)}>button1</button>
<button onClick={() => setCount2((c) => c + 1)}>button2</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count1: 1, count2: 2')
fireEvent.click(getByText('button1'))
await findByText('count1: 2, count2: 4')
fireEvent.click(getByText('button2'))
await findByText('count1: 2, count2: 5')
fireEvent.click(getByText('button1'))
await findByText('count1: 3, count2: 5')
})
it('simple async get default', async () => {
const count1Atom = atom(1)
let resolve = () => {}
const count2Atom = atomWithDefault(async (get) => {
await new Promise<void>((r) => (resolve = r))
return get(count1Atom) * 2
})
const Counter = () => {
const [count1, setCount1] = useAtom(count1Atom)
const [count2, setCount2] = useAtom(count2Atom)
return (
<>
<div>
count1: {count1}, count2: {count2}
</div>
<button onClick={() => setCount1((c) => c + 1)}>button1</button>
<button onClick={() => setCount2((p) => p.then((c) => c + 1))}>
button2
</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('loading')
resolve()
await findByText('count1: 1, count2: 2')
fireEvent.click(getByText('button1'))
await findByText('loading')
resolve()
await findByText('count1: 2, count2: 4')
fireEvent.click(getByText('button2'))
resolve()
await findByText('count1: 2, count2: 5')
fireEvent.click(getByText('button1'))
resolve()
await findByText('count1: 3, count2: 5')
})
it('refresh sync atoms to default values', async () => {
const count1Atom = atom(1)
const count2Atom = atomWithDefault((get) => get(count1Atom) * 2)
const Counter = () => {
const [count1, setCount1] = useAtom(count1Atom)
const [count2, setCount2] = useAtom(count2Atom)
return (
<>
<div>
count1: {count1}, count2: {count2}
</div>
<button onClick={() => setCount1((c) => c + 1)}>button1</button>
<button onClick={() => setCount2((c) => c + 1)}>button2</button>
<button onClick={() => setCount2(RESET)}>Refresh count2</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count1: 1, count2: 2')
fireEvent.click(getByText('button1'))
await findByText('count1: 2, count2: 4')
fireEvent.click(getByText('button2'))
await findByText('count1: 2, count2: 5')
fireEvent.click(getByText('button1'))
await findByText('count1: 3, count2: 5')
fireEvent.click(getByText('Refresh count2'))
await findByText('count1: 3, count2: 6')
fireEvent.click(getByText('button1'))
await findByText('count1: 4, count2: 8')
})
it('refresh async atoms to default values', async () => {
const count1Atom = atom(1)
let resolve = () => {}
const count2Atom = atomWithDefault(async (get) => {
await new Promise<void>((r) => (resolve = r))
return get(count1Atom) * 2
})
const Counter = () => {
const [count1, setCount1] = useAtom(count1Atom)
const [count2, setCount2] = useAtom(count2Atom)
return (
<>
<div>
count1: {count1}, count2: {count2}
</div>
<button onClick={() => setCount1((c) => c + 1)}>button1</button>
<button onClick={() => setCount2((p) => p.then((c) => c + 1))}>
button2
</button>
<button onClick={() => setCount2(RESET)}>Refresh count2</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('loading')
await waitFor(() => {
resolve()
getByText('count1: 1, count2: 2')
})
fireEvent.click(getByText('button1'))
await findByText('loading')
await waitFor(() => {
resolve()
getByText('count1: 2, count2: 4')
})
fireEvent.click(getByText('button2'))
await waitFor(() => {
resolve()
getByText('count1: 2, count2: 5')
})
fireEvent.click(getByText('button1'))
await waitFor(() => {
resolve()
getByText('count1: 3, count2: 5')
})
fireEvent.click(getByText('Refresh count2'))
await waitFor(() => {
resolve()
getByText('count1: 3, count2: 6')
})
fireEvent.click(getByText('button1'))
await waitFor(() => {
resolve()
getByText('count1: 4, count2: 8')
})
})
|
6,847 | 0 | petrpan-code/pmndrs/jotai/tests/react | petrpan-code/pmndrs/jotai/tests/react/vanilla-utils/atomWithObservable.test.tsx | import { Component, StrictMode, Suspense, useState } from 'react'
import type { ReactElement, ReactNode } from 'react'
import { act, fireEvent, render, waitFor } from '@testing-library/react'
import { BehaviorSubject, Observable, Subject, delay, map, of } from 'rxjs'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { fromValue, makeSubject, pipe, toObservable } from 'wonka'
import { useAtom, useAtomValue, useSetAtom } from 'jotai/react'
import { atom, createStore } from 'jotai/vanilla'
import { atomWithObservable } from 'jotai/vanilla/utils'
const consoleError = console.error
beforeEach(() => {
vi.useFakeTimers({ shouldAdvanceTime: true })
// A workaround for missing performance.mark after using fake timers
// https://github.com/pmndrs/jotai/pull/1913#discussion_r1186527192
if (!performance.mark) {
performance.mark = (() => {}) as any
performance.clearMarks = (() => {}) as any
performance.clearMeasures = (() => {}) as any
}
// suppress ErrorBoundary error log
console.error = vi.fn((message: unknown, ...optionalParams: unknown[]) => {
if (
typeof message === 'string' &&
(message.includes('Error: Uncaught [Error: Test Error]') ||
message.includes('at ErrorBoundary'))
) {
return
}
return consoleError(message, ...optionalParams)
})
})
afterEach(() => {
vi.runAllTimers()
vi.useRealTimers()
console.error = consoleError
})
class ErrorBoundary extends Component<
{ children: ReactNode },
{ error: string }
> {
state = {
error: '',
}
static getDerivedStateFromError(error: Error) {
return { error: error.message }
}
render() {
if (this.state.error) {
return <div>Error: {this.state.error}</div>
}
return this.props.children
}
}
it('count state', async () => {
const observableAtom = atomWithObservable(() => of(1))
const Counter = () => {
const [state] = useAtom(observableAtom)
return <>count: {state}</>
}
const { findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('count: 1')
})
it('writable count state', async () => {
const subject = new BehaviorSubject(1)
const observableAtom = atomWithObservable(() => subject)
const Counter = () => {
const [state, dispatch] = useAtom(observableAtom)
return (
<>
count: {state}
<button onClick={() => dispatch(9)}>button</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('count: 1')
act(() => subject.next(2))
await findByText('count: 2')
fireEvent.click(getByText('button'))
await findByText('count: 9')
expect(subject.value).toBe(9)
expect(subject)
})
it('writable count state without initial value', async () => {
const subject = new Subject<number>()
const observableAtom = atomWithObservable(() => subject)
const CounterValue = () => {
const state = useAtomValue(observableAtom)
return <>count: {state}</>
}
const CounterButton = () => {
const dispatch = useSetAtom(observableAtom)
return <button onClick={() => dispatch(9)}>button</button>
}
const { findByText, getByText } = render(
<StrictMode>
<Suspense fallback="loading">
<CounterValue />
</Suspense>
<CounterButton />
</StrictMode>,
)
await findByText('loading')
fireEvent.click(getByText('button'))
await findByText('count: 9')
act(() => subject.next(3))
await findByText('count: 3')
})
it('writable count state with delayed value', async () => {
const subject = new Subject<number>()
const observableAtom = atomWithObservable(() => {
const observable = of(1).pipe(delay(10 * 1000))
observable.subscribe((n) => subject.next(n))
return subject
})
const Counter = () => {
const [state, dispatch] = useAtom(observableAtom)
return (
<>
count: {state}
<button
onClick={() => {
dispatch(9)
}}
>
button
</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('loading')
act(() => vi.runOnlyPendingTimers())
await findByText('count: 1')
fireEvent.click(getByText('button'))
await findByText('count: 9')
})
it('only subscribe once per atom', async () => {
const subject = new Subject()
let totalSubscriptions = 0
const observable = new Observable((subscriber) => {
totalSubscriptions++
subject.subscribe(subscriber)
})
const observableAtom = atomWithObservable(() => observable)
const Counter = () => {
const [state] = useAtom(observableAtom)
return <>count: {state}</>
}
const { findByText, rerender } = render(
<>
<Suspense fallback="loading">
<Counter />
</Suspense>
</>,
)
await findByText('loading')
act(() => subject.next(1))
await findByText('count: 1')
rerender(<div />)
expect(totalSubscriptions).toEqual(1)
rerender(
<>
<Suspense fallback="loading">
<Counter />
</Suspense>
</>,
)
act(() => subject.next(2))
await findByText('count: 2')
expect(totalSubscriptions).toEqual(2)
})
it('cleanup subscription', async () => {
const subject = new Subject()
let activeSubscriptions = 0
const observable = new Observable((subscriber) => {
activeSubscriptions++
subject.subscribe(subscriber)
return () => {
activeSubscriptions--
}
})
const observableAtom = atomWithObservable(() => observable)
const Counter = () => {
const [state] = useAtom(observableAtom)
return <>count: {state}</>
}
const { findByText, rerender } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('loading')
act(() => subject.next(1))
await findByText('count: 1')
expect(activeSubscriptions).toEqual(1)
rerender(<div />)
await waitFor(() => expect(activeSubscriptions).toEqual(0))
})
it('resubscribe on remount', async () => {
const subject = new Subject<number>()
const observableAtom = atomWithObservable(() => subject)
const Counter = () => {
const [state] = useAtom(observableAtom)
return <>count: {state}</>
}
const Toggle = ({ children }: { children: ReactElement }) => {
const [visible, setVisible] = useState(true)
return (
<>
{visible && children}
<button onClick={() => setVisible(!visible)}>Toggle</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Toggle>
<Counter />
</Toggle>
</Suspense>
</StrictMode>,
)
await findByText('loading')
act(() => subject.next(1))
await findByText('count: 1')
fireEvent.click(getByText('Toggle'))
fireEvent.click(getByText('Toggle'))
act(() => subject.next(2))
await findByText('count: 2')
})
it("count state with initialValue doesn't suspend", async () => {
const subject = new Subject<number>()
const observableAtom = atomWithObservable(() => subject, { initialValue: 5 })
const Counter = () => {
const [state] = useAtom(observableAtom)
return <>count: {state}</>
}
const { findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 5')
act(() => subject.next(10))
await findByText('count: 10')
})
it('writable count state with initialValue', async () => {
const subject = new Subject<number>()
const observableAtom = atomWithObservable(() => subject, { initialValue: 5 })
const Counter = () => {
const [state, dispatch] = useAtom(observableAtom)
return (
<>
count: {state}
<button onClick={() => dispatch(9)}>button</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('count: 5')
act(() => subject.next(1))
await findByText('count: 1')
fireEvent.click(getByText('button'))
await findByText('count: 9')
})
it('writable count state with error', async () => {
const subject = new Subject<number>()
const observableAtom = atomWithObservable(() => subject)
const Counter = () => {
const [state, dispatch] = useAtom(observableAtom)
return (
<>
count: {state}
<button onClick={() => dispatch(9)}>button</button>
</>
)
}
const { findByText } = render(
<StrictMode>
<ErrorBoundary>
<Suspense fallback="loading">
<Counter />
</Suspense>
</ErrorBoundary>
</StrictMode>,
)
await findByText('loading')
act(() => subject.error(new Error('Test Error')))
await findByText('Error: Test Error')
})
it('synchronous subscription with initial value', async () => {
const observableAtom = atomWithObservable(() => of(1), { initialValue: 5 })
const Counter = () => {
const [state] = useAtom(observableAtom)
return <>count: {state}</>
}
const { findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 1')
})
it('synchronous subscription with BehaviorSubject', async () => {
const observableAtom = atomWithObservable(() => new BehaviorSubject(1))
const Counter = () => {
const [state] = useAtom(observableAtom)
return <>count: {state}</>
}
const { findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 1')
})
it('synchronous subscription with already emitted value', async () => {
const observableAtom = atomWithObservable(() => of(1))
const Counter = () => {
const [state] = useAtom(observableAtom)
return <>count: {state}</>
}
const { findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 1')
})
it('with falsy initial value', async () => {
const observableAtom = atomWithObservable(() => new Subject<number>(), {
initialValue: 0,
})
const Counter = () => {
const [state] = useAtom(observableAtom)
return <>count: {state}</>
}
const { findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
})
it('with initially emitted undefined value', async () => {
const subject = new Subject<number | undefined | null>()
const observableAtom = atomWithObservable(() => subject)
const Counter = () => {
const [state] = useAtom(observableAtom)
return <>count: {state === undefined ? '-' : state}</>
}
const { findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('loading')
act(() => subject.next(undefined))
await findByText('count: -')
act(() => subject.next(1))
await findByText('count: 1')
})
it("don't omit values emitted between init and mount", async () => {
const subject = new Subject<number>()
const observableAtom = atomWithObservable(() => subject)
const Counter = () => {
const [state, dispatch] = useAtom(observableAtom)
return (
<>
count: {state}
<button
onClick={() => {
dispatch(9)
}}
>
button
</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('loading')
act(() => {
subject.next(1)
subject.next(2)
})
await findByText('count: 2')
fireEvent.click(getByText('button'))
await findByText('count: 9')
})
describe('error handling', () => {
class ErrorBoundary extends Component<
{ message?: string; retry?: () => void; children: ReactNode },
{ hasError: boolean }
> {
constructor(props: { message?: string; children: ReactNode }) {
super(props)
this.state = { hasError: false }
}
static getDerivedStateFromError() {
return { hasError: true }
}
render() {
return this.state.hasError ? (
<div>
{this.props.message || 'errored'}
{this.props.retry && (
<button
onClick={() => {
this.props.retry?.()
this.setState({ hasError: false })
}}
>
retry
</button>
)}
</div>
) : (
this.props.children
)
}
}
it('can catch error in error boundary', async () => {
const subject = new Subject<number>()
const countAtom = atomWithObservable(() => subject)
const Counter = () => {
const [count] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
</>
)
}
const { findByText } = render(
<StrictMode>
<ErrorBoundary>
<Suspense fallback="loading">
<Counter />
</Suspense>
</ErrorBoundary>
</StrictMode>,
)
await findByText('loading')
act(() => subject.error(new Error('Test Error')))
await findByText('errored')
})
it('can recover from error with dependency', async () => {
const baseAtom = atom(0)
const countAtom = atomWithObservable((get) => {
const base = get(baseAtom)
if (base % 2 === 0) {
const subject = new Subject<number>()
const observable = of(1).pipe(delay(10 * 1000))
observable.subscribe(() => subject.error(new Error('Test Error')))
return subject
}
const observable = of(base).pipe(delay(10 * 1000))
return observable
})
const Counter = () => {
const [count] = useAtom(countAtom)
const setBase = useSetAtom(baseAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => setBase((v) => v + 1)}>next</button>
</>
)
}
const App = () => {
const setBase = useSetAtom(baseAtom)
const retry = () => {
setBase((c) => c + 1)
}
return (
<ErrorBoundary retry={retry}>
<Suspense fallback="loading">
<Counter />
</Suspense>
</ErrorBoundary>
)
}
const { findByText, getByText } = render(
<StrictMode>
<App />
</StrictMode>,
)
await findByText('loading')
act(() => vi.runOnlyPendingTimers())
await findByText('errored')
fireEvent.click(getByText('retry'))
await findByText('loading')
act(() => vi.runOnlyPendingTimers())
await findByText('count: 1')
fireEvent.click(getByText('next'))
await findByText('loading')
act(() => vi.runOnlyPendingTimers())
await findByText('errored')
fireEvent.click(getByText('retry'))
await findByText('loading')
act(() => vi.runOnlyPendingTimers())
await findByText('count: 3')
})
it('can recover with intermediate atom', async () => {
let count = -1
let willThrowError = false
const refreshAtom = atom(0)
const countObservableAtom = atom((get) => {
get(refreshAtom)
const observableAtom = atomWithObservable(() => {
willThrowError = !willThrowError
++count
const subject = new Subject<{ data: number } | { error: Error }>()
setTimeout(() => {
if (willThrowError) {
subject.next({ error: new Error('Test Error') })
} else {
subject.next({ data: count })
}
}, 10 * 1000)
return subject
})
return observableAtom
})
const derivedAtom = atom((get) => {
const observableAtom = get(countObservableAtom)
const result = get(observableAtom)
if (result instanceof Promise) {
return result.then((result) => {
if ('error' in result) {
throw result.error
}
return result.data
})
}
if ('error' in result) {
throw result.error
}
return result.data
})
const Counter = () => {
const [count] = useAtom(derivedAtom)
const refresh = useSetAtom(refreshAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => refresh((c) => c + 1)}>refresh</button>
</>
)
}
const App = () => {
const refresh = useSetAtom(refreshAtom)
const retry = () => {
refresh((c) => c + 1)
}
return (
<ErrorBoundary retry={retry}>
<Suspense fallback="loading">
<Counter />
</Suspense>
</ErrorBoundary>
)
}
const { findByText, getByText } = render(
<StrictMode>
<App />
</StrictMode>,
)
await findByText('loading')
act(() => vi.runOnlyPendingTimers())
await findByText('errored')
fireEvent.click(getByText('retry'))
await findByText('loading')
act(() => vi.runOnlyPendingTimers())
await findByText('count: 1')
fireEvent.click(getByText('refresh'))
await findByText('loading')
act(() => vi.runOnlyPendingTimers())
await findByText('errored')
fireEvent.click(getByText('retry'))
await findByText('loading')
act(() => vi.runOnlyPendingTimers())
await findByText('count: 3')
})
})
describe('wonka', () => {
it('count state', async () => {
const source = fromValue(1)
const observable = pipe(source, toObservable)
const observableAtom = atomWithObservable(() => observable)
const Counter = () => {
const [count] = useAtom(observableAtom)
return <>count: {count}</>
}
const { findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('count: 1')
})
it('make subject', async () => {
const subject = makeSubject<number>()
const observable = pipe(subject.source, toObservable)
const observableAtom = atomWithObservable(() => observable)
const countAtom = atom(
(get) => get(observableAtom),
(_get, _set, nextValue: number) => {
subject.next(nextValue)
},
)
const Counter = () => {
const [count] = useAtom(countAtom)
return <>count: {count}</>
}
const Controls = () => {
const setCount = useSetAtom(countAtom)
return <button onClick={() => setCount(1)}>button</button>
}
const { findByText, getByText } = render(
<StrictMode>
<Controls />
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('loading')
fireEvent.click(getByText('button'))
await findByText('count: 1')
})
})
describe('atomWithObservable vanilla tests', () => {
it('can propagate updates with async atom chains', async () => {
const store = createStore()
const subject = new BehaviorSubject(1)
const countAtom = atomWithObservable(() => subject)
const asyncAtom = atom(async (get) => get(countAtom))
const async2Atom = atom((get) => get(asyncAtom))
const unsub = store.sub(async2Atom, () => {})
await expect(store.get(async2Atom)).resolves.toBe(1)
subject.next(2)
await expect(store.get(async2Atom)).resolves.toBe(2)
subject.next(3)
await expect(store.get(async2Atom)).resolves.toBe(3)
unsub()
})
it('can propagate updates with rxjs chains', async () => {
const store = createStore()
const single$ = new Subject<number>()
const double$ = single$.pipe(map((n) => n * 2))
const singleAtom = atomWithObservable(() => single$)
const doubleAtom = atomWithObservable(() => double$)
const unsubs = [
store.sub(singleAtom, () => {}),
store.sub(doubleAtom, () => {}),
]
single$.next(1)
expect(store.get(singleAtom)).toBe(1)
expect(store.get(doubleAtom)).toBe(2)
single$.next(2)
expect(store.get(singleAtom)).toBe(2)
expect(store.get(doubleAtom)).toBe(4)
single$.next(3)
expect(store.get(singleAtom)).toBe(3)
expect(store.get(doubleAtom)).toBe(6)
unsubs.forEach((unsub) => unsub())
})
})
|
6,848 | 0 | petrpan-code/pmndrs/jotai/tests/react | petrpan-code/pmndrs/jotai/tests/react/vanilla-utils/atomWithReducer.test.tsx | import { StrictMode } from 'react'
import { fireEvent, render } from '@testing-library/react'
import { it } from 'vitest'
import { useAtom } from 'jotai/react'
import { atomWithReducer } from 'jotai/vanilla/utils'
it('atomWithReducer with optional action argument', async () => {
const reducer = (state: number, action?: 'INCREASE' | 'DECREASE') => {
switch (action) {
case 'INCREASE':
return state + 1
case 'DECREASE':
return state - 1
case undefined:
return state
}
}
const countAtom = atomWithReducer(0, reducer)
const Parent = () => {
const [count, dispatch] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => dispatch('INCREASE')}>dispatch INCREASE</button>
<button onClick={() => dispatch('DECREASE')}>dispatch DECREASE</button>
<button onClick={() => dispatch()}>dispatch empty</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Parent />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('dispatch INCREASE'))
await findByText('count: 1')
fireEvent.click(getByText('dispatch empty'))
await findByText('count: 1')
fireEvent.click(getByText('dispatch DECREASE'))
await findByText('count: 0')
})
it('atomWithReducer with non-optional action argument', async () => {
const reducer = (state: number, action: 'INCREASE' | 'DECREASE') => {
switch (action) {
case 'INCREASE':
return state + 1
case 'DECREASE':
return state - 1
}
}
const countAtom = atomWithReducer(0, reducer)
const Parent = () => {
const [count, dispatch] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => dispatch('INCREASE')}>dispatch INCREASE</button>
<button onClick={() => dispatch('DECREASE')}>dispatch DECREASE</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Parent />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('dispatch INCREASE'))
await findByText('count: 1')
fireEvent.click(getByText('dispatch DECREASE'))
await findByText('count: 0')
})
|
6,849 | 0 | petrpan-code/pmndrs/jotai/tests/react | petrpan-code/pmndrs/jotai/tests/react/vanilla-utils/atomWithStorage.test.tsx | import { StrictMode, Suspense } from 'react'
import { act, fireEvent, render, waitFor } from '@testing-library/react'
import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
import { useAtom } from 'jotai/react'
import { atom, createStore } from 'jotai/vanilla'
import { RESET, atomWithStorage, createJSONStorage } from 'jotai/vanilla/utils'
const resolve: (() => void)[] = []
describe('atomWithStorage (sync)', () => {
const storageData: Record<string, number> = {
count: 10,
}
const dummyStorage = {
getItem: (key: string, initialValue: number) => {
if (!(key in storageData)) {
return initialValue
}
return storageData[key] as number
},
setItem: (key: string, newValue: number) => {
storageData[key] = newValue
},
removeItem: (key: string) => {
delete storageData[key]
},
listeners: new Set<(key: string, value: number | null) => void>(),
emitStorageEvent: (key: string, newValue: number | null) => {
dummyStorage.listeners.forEach((listener) => {
listener(key, newValue)
})
},
subscribe: (
key: string,
callback: (value: number) => void,
initialValue: number,
) => {
const listener = (k: string, value: number | null) => {
if (k === key) {
callback(value ?? initialValue)
}
}
dummyStorage.listeners.add(listener)
return () => dummyStorage.listeners.delete(listener)
},
}
it('simple count', async () => {
const countAtom = atomWithStorage('count', 1, dummyStorage)
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
<button onClick={() => setCount(RESET)}>reset</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 10')
fireEvent.click(getByText('button'))
await findByText('count: 11')
expect(storageData.count).toBe(11)
fireEvent.click(getByText('reset'))
await findByText('count: 1')
expect(storageData.count).toBeUndefined()
})
it('storage updates before mount (#1079)', async () => {
dummyStorage.setItem('count', 10)
const countAtom = atomWithStorage('count', 1, dummyStorage)
const Counter = () => {
const [count] = useAtom(countAtom)
// emulating updating before mount
if (dummyStorage.getItem('count', 1) !== 9) {
dummyStorage.emitStorageEvent('count', 9)
}
return <div>count: {count}</div>
}
const { findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 9')
})
})
describe('with sync string storage', () => {
const storageData: Record<string, string> = {
count: '10',
}
const stringStorage = {
getItem: (key: string) => {
return storageData[key] || null
},
setItem: (key: string, newValue: string) => {
storageData[key] = newValue
},
removeItem: (key: string) => {
delete storageData[key]
},
listeners: new Set<(key: string, value: string | null) => void>(),
emitStorageEvent: (key: string, newValue: string | null) => {
stringStorage.listeners.forEach((listener) => {
listener(key, newValue)
})
},
}
const dummyStorage = createJSONStorage<number>(() => stringStorage)
dummyStorage.subscribe = (key, callback, initialValue) => {
const listener = (k: string, value: string | null) => {
if (k === key) {
let newValue: number
try {
newValue = JSON.parse(value ?? '')
} catch {
newValue = initialValue
}
callback(newValue)
}
}
stringStorage.listeners.add(listener)
return () => stringStorage.listeners.delete(listener)
}
it('simple count', async () => {
const countAtom = atomWithStorage('count', 1, dummyStorage)
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => setCount((c) => c + 1)}>button</button>
<button onClick={() => setCount(RESET)}>reset</button>
<button onClick={() => setCount((c) => (c === 2 ? RESET : c + 1))}>
conditional reset
</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 10')
fireEvent.click(getByText('button'))
await findByText('count: 11')
expect(storageData.count).toBe('11')
fireEvent.click(getByText('reset'))
await findByText('count: 1')
expect(storageData.count).toBeUndefined()
fireEvent.click(getByText('button'))
await findByText('count: 2')
expect(storageData.count).toBe('2')
fireEvent.click(getByText('conditional reset'))
await findByText('count: 1')
expect(storageData.count).toBeUndefined()
})
it('no entry (#1086)', async () => {
const noentryAtom = atomWithStorage('noentry', -1, dummyStorage)
const Counter = () => {
const [noentry] = useAtom(noentryAtom)
return <div>noentry: {noentry}</div>
}
const { findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('noentry: -1')
})
})
describe('atomWithStorage (async)', () => {
const asyncStorageData: Record<string, number> = {
count: 10,
}
const asyncDummyStorage = {
getItem: async (key: string, initialValue: number) => {
await new Promise<void>((r) => resolve.push(r))
if (!(key in asyncStorageData)) {
return initialValue
}
return asyncStorageData[key] as number
},
setItem: async (key: string, newValue: number) => {
await new Promise<void>((r) => resolve.push(r))
asyncStorageData[key] = newValue
},
removeItem: async (key: string) => {
await new Promise<void>((r) => resolve.push(r))
delete asyncStorageData[key]
},
}
it('async count', async () => {
const countAtom = atomWithStorage('count', 1, asyncDummyStorage)
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => setCount(async (c) => (await c) + 1)}>
button
</button>
<button onClick={() => setCount(RESET)}>reset</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
act(() => resolve.splice(0).forEach((fn) => fn()))
await findByText('count: 10')
fireEvent.click(getByText('button'))
act(() => resolve.splice(0).forEach((fn) => fn()))
await findByText('count: 11')
act(() => resolve.splice(0).forEach((fn) => fn()))
await waitFor(() => {
expect(asyncStorageData.count).toBe(11)
})
fireEvent.click(getByText('reset'))
act(() => resolve.splice(0).forEach((fn) => fn()))
await findByText('count: 1')
await waitFor(() => {
expect(asyncStorageData.count).toBeUndefined()
})
})
it('async new count', async () => {
const countAtom = atomWithStorage('count2', 20, asyncDummyStorage)
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => setCount(async (c) => (await c) + 1)}>
button
</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('count: 20')
fireEvent.click(getByText('button'))
act(() => resolve.splice(0).forEach((fn) => fn()))
await findByText('count: 21')
act(() => resolve.splice(0).forEach((fn) => fn()))
await waitFor(() => {
expect(asyncStorageData.count2).toBe(21)
})
})
})
describe('atomWithStorage (without localStorage) (#949)', () => {
it('createJSONStorage without localStorage', async () => {
const countAtom = atomWithStorage(
'count',
1,
createJSONStorage(() => undefined as any),
)
const Counter = () => {
const [count, setCount] = useAtom(countAtom)
return (
<>
<div>count: {count}</div>
<button onClick={() => setCount(async (c) => (await c) + 1)}>
button
</button>
</>
)
}
const { findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 1')
})
})
describe('atomWithStorage (in non-browser environment)', () => {
const asyncStorageData: Record<string, string> = {
count: '10',
}
const asyncDummyStorage = {
getItem: async (key: string) => {
await new Promise<void>((r) => resolve.push(r))
return asyncStorageData[key] as string
},
setItem: async (key: string, newValue: string) => {
await new Promise<void>((r) => resolve.push(r))
asyncStorageData[key] = newValue
},
removeItem: async (key: string) => {
await new Promise<void>((r) => resolve.push(r))
delete asyncStorageData[key]
},
}
const addEventListener = window.addEventListener
beforeAll(() => {
;(window as any).addEventListener = undefined
})
afterAll(() => {
window.addEventListener = addEventListener
})
it('createJSONStorage with undefined window.addEventListener', async () => {
const storage = createJSONStorage(() => asyncDummyStorage)
expect(storage.subscribe).toBeUndefined()
})
})
describe('atomWithStorage (with browser storage)', () => {
const addEventListener = window.addEventListener
const mockAddEventListener = vi.fn()
beforeAll(() => {
;(window as any).addEventListener = mockAddEventListener
})
afterAll(() => {
window.addEventListener = addEventListener
})
it('createJSONStorage subscribes to specific window storage events', async () => {
const store = createStore()
const mockNativeStorage = Object.create(window.Storage.prototype)
mockNativeStorage.setItem = vi.fn() as Storage['setItem']
mockNativeStorage.getItem = vi.fn(() => null) as Storage['getItem']
mockNativeStorage.removeItem = vi.fn() as Storage['removeItem']
const dummyAtom = atomWithStorage<number>(
'dummy',
1,
createJSONStorage<number>(() => mockNativeStorage),
)
const DummyComponent = () => {
const [value] = useAtom(dummyAtom, { store })
return (
<>
<div>{value}</div>
</>
)
}
render(
<StrictMode>
<DummyComponent />
</StrictMode>,
)
expect(mockAddEventListener).toHaveBeenCalledWith(
'storage',
expect.any(Function),
)
const storageEventHandler = mockAddEventListener.mock.calls
.filter(([eventName]: [string]) => eventName === 'storage')
.pop()?.[1] as (e: StorageEvent) => void
expect(store.get(dummyAtom)).toBe(1)
act(() => {
storageEventHandler?.({
key: 'dummy',
newValue: '2',
storageArea: {},
} as StorageEvent)
})
expect(store.get(dummyAtom)).toBe(1)
act(() => {
storageEventHandler?.({
key: 'dummy',
newValue: '2',
storageArea: mockNativeStorage,
} as StorageEvent)
})
expect(store.get(dummyAtom)).toBe(2)
act(() => {
// simulate removeItem() from another window
storageEventHandler?.({
key: 'dummy',
newValue: null,
storageArea: mockNativeStorage,
} as StorageEvent)
})
expect(store.get(dummyAtom)).toBe(1)
})
it("should recompute dependents' state after onMount (#2098)", async () => {
const store = createStore()
let currentValue: string | null = 'true'
const mockNativeStorage = {
setItem: vi.fn((_key: string, value: string) => (currentValue = value)),
getItem: vi.fn(() => currentValue),
removeItem: vi.fn(() => (currentValue = null)),
}
const isLoggedAtom = atom(false)
const isDevModeStorageAtom = atomWithStorage(
'isDevModeStorageAtom',
false,
createJSONStorage<boolean>(() => mockNativeStorage),
)
const isDevModeState = atom(
(get) => {
if (!get(isLoggedAtom)) return false
return get(isDevModeStorageAtom)
},
(get, set, value: boolean) => {
set(isDevModeStorageAtom, value)
},
)
const DummyComponent = () => {
const [isLogged] = useAtom(isLoggedAtom, { store })
const [value, setValue] = useAtom(isDevModeState, { store })
return isLogged ? (
<input
type="checkbox"
checked={value}
onChange={() => setValue(!value)}
/>
) : null
}
const { getByRole } = render(
<StrictMode>
<DummyComponent />
</StrictMode>,
)
act(() => store.set(isLoggedAtom, true))
const checkbox = getByRole('checkbox') as HTMLInputElement
expect(store.get(isLoggedAtom)).toBeTruthy()
expect(store.get(isDevModeStorageAtom)).toBeTruthy()
expect(checkbox.checked).toBeTruthy()
fireEvent.click(checkbox)
expect(checkbox.checked).toBeFalsy()
})
})
describe('atomWithStorage (with non-browser storage)', () => {
const addEventListener = window.addEventListener
const mockAddEventListener = vi.fn()
beforeAll(() => {
;(window as any).addEventListener = mockAddEventListener
})
afterAll(() => {
window.addEventListener = addEventListener
})
it('createJSONStorage avoids attaching event handler for non-browser storage', async () => {
const store = createStore()
const mockNonNativeStorage = {
setItem: vi.fn() as Storage['setItem'],
getItem: vi.fn(() => null) as Storage['getItem'],
removeItem: vi.fn() as Storage['removeItem'],
}
const dummyAtom = atomWithStorage<number>(
'dummy',
1,
createJSONStorage<number>(() => mockNonNativeStorage),
)
const DummyComponent = () => {
const [value] = useAtom(dummyAtom, { store })
return (
<>
<div>{value}</div>
</>
)
}
render(
<StrictMode>
<DummyComponent />
</StrictMode>,
)
expect(mockAddEventListener).not.toHaveBeenCalledWith(
'storage',
expect.any(Function),
)
})
})
|
6,850 | 0 | petrpan-code/pmndrs/jotai/tests/react | petrpan-code/pmndrs/jotai/tests/react/vanilla-utils/freezeAtom.test.tsx | import { StrictMode } from 'react'
import { render } from '@testing-library/react'
import { it } from 'vitest'
import { useAtom } from 'jotai/react'
import { atom } from 'jotai/vanilla'
import { freezeAtom, freezeAtomCreator } from 'jotai/vanilla/utils'
it('freezeAtom basic test', async () => {
const objAtom = atom({ count: 0 })
const Component = () => {
const [obj] = useAtom(freezeAtom(objAtom))
return <div>isFrozen: {`${Object.isFrozen(obj)}`}</div>
}
const { findByText } = render(
<StrictMode>
<Component />
</StrictMode>,
)
await findByText('isFrozen: true')
})
it('freezeAtomCreator basic test', async () => {
const createFrozenAtom = freezeAtomCreator(atom)
const objAtom = createFrozenAtom({ count: 0 })
const Component = () => {
const [obj] = useAtom(objAtom)
return <div>isFrozen: {`${Object.isFrozen(obj)}`}</div>
}
const { findByText } = render(
<StrictMode>
<Component />
</StrictMode>,
)
await findByText('isFrozen: true')
})
|
6,851 | 0 | petrpan-code/pmndrs/jotai/tests/react | petrpan-code/pmndrs/jotai/tests/react/vanilla-utils/loadable.test.tsx | import { StrictMode, Suspense, useEffect } from 'react'
import { fireEvent, render } from '@testing-library/react'
import { expect, it, vi } from 'vitest'
import { useAtomValue, useSetAtom } from 'jotai/react'
import { atom } from 'jotai/vanilla'
import type { Atom } from 'jotai/vanilla'
import { loadable } from 'jotai/vanilla/utils'
it('loadable turns suspense into values', async () => {
let resolve: (x: number) => void = () => {}
const asyncAtom = atom(() => {
return new Promise<number>((r) => (resolve = r))
})
const { findByText } = render(
<StrictMode>
<LoadableComponent asyncAtom={asyncAtom} />
</StrictMode>,
)
await findByText('Loading...')
resolve(5)
await findByText('Data: 5')
})
it('loadable turns errors into values', async () => {
let reject: (error: unknown) => void = () => {}
const asyncAtom = atom(() => {
return new Promise<number>((_res, rej) => (reject = rej))
})
const { findByText } = render(
<StrictMode>
<LoadableComponent asyncAtom={asyncAtom} />
</StrictMode>,
)
await findByText('Loading...')
reject(new Error('An error occurred'))
await findByText('Error: An error occurred')
})
it('loadable turns primitive throws into values', async () => {
let reject: (error: unknown) => void = () => {}
const asyncAtom = atom(() => {
return new Promise<number>((_res, rej) => (reject = rej))
})
const { findByText } = render(
<StrictMode>
<LoadableComponent asyncAtom={asyncAtom} />
</StrictMode>,
)
await findByText('Loading...')
reject('An error occurred')
await findByText('An error occurred')
})
it('loadable goes back to loading after re-fetch', async () => {
let resolve: (x: number) => void = () => {}
const refreshAtom = atom(0)
const asyncAtom = atom((get) => {
get(refreshAtom)
return new Promise<number>((r) => (resolve = r))
})
const Refresh = () => {
const setRefresh = useSetAtom(refreshAtom)
return (
<>
<button onClick={() => setRefresh((value) => value + 1)}>
refresh
</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Refresh />
<LoadableComponent asyncAtom={asyncAtom} />
</StrictMode>,
)
getByText('Loading...')
resolve(5)
await findByText('Data: 5')
fireEvent.click(getByText('refresh'))
await findByText('Loading...')
resolve(6)
await findByText('Data: 6')
})
it('loadable can recover from error', async () => {
let resolve: (x: number) => void = () => {}
let reject: (error: unknown) => void = () => {}
const refreshAtom = atom(0)
const asyncAtom = atom((get) => {
get(refreshAtom)
return new Promise<number>((res, rej) => {
resolve = res
reject = rej
})
})
const Refresh = () => {
const setRefresh = useSetAtom(refreshAtom)
return (
<>
<button onClick={() => setRefresh((value) => value + 1)}>
refresh
</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Refresh />
<LoadableComponent asyncAtom={asyncAtom} />
</StrictMode>,
)
getByText('Loading...')
reject(new Error('An error occurred'))
await findByText('Error: An error occurred')
fireEvent.click(getByText('refresh'))
await findByText('Loading...')
resolve(6)
await findByText('Data: 6')
})
it('loadable immediately resolves sync values', async () => {
const syncAtom = atom(5)
const effectCallback = vi.fn()
const { getByText } = render(
<StrictMode>
<LoadableComponent effectCallback={effectCallback} asyncAtom={syncAtom} />
</StrictMode>,
)
getByText('Data: 5')
expect(effectCallback.mock.calls).not.toContain(
expect.objectContaining({ state: 'loading' }),
)
expect(effectCallback).toHaveBeenLastCalledWith({ state: 'hasData', data: 5 })
})
it('loadable can use resolved promises synchronously', async () => {
const asyncAtom = atom(Promise.resolve(5))
const effectCallback = vi.fn()
const ResolveAtomComponent = () => {
useAtomValue(asyncAtom)
return <div>Ready</div>
}
const { findByText, rerender } = render(
<StrictMode>
<Suspense fallback={null}>
<ResolveAtomComponent />
</Suspense>
</StrictMode>,
)
await findByText('Ready')
rerender(
<StrictMode>
<LoadableComponent
effectCallback={effectCallback}
asyncAtom={asyncAtom}
/>
</StrictMode>,
)
await findByText('Data: 5')
expect(effectCallback.mock.calls).not.toContain(
expect.objectContaining({ state: 'loading' }),
)
expect(effectCallback).toHaveBeenLastCalledWith({ state: 'hasData', data: 5 })
})
it('loadable of a derived async atom does not trigger infinite loop (#1114)', async () => {
let resolve: (x: number) => void = () => {}
const baseAtom = atom(0)
const asyncAtom = atom((get) => {
get(baseAtom)
return new Promise<number>((r) => (resolve = r))
})
const Trigger = () => {
const trigger = useSetAtom(baseAtom)
return (
<>
<button onClick={() => trigger((value) => value)}>trigger</button>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Trigger />
<LoadableComponent asyncAtom={asyncAtom} />
</StrictMode>,
)
getByText('Loading...')
fireEvent.click(getByText('trigger'))
resolve(5)
await findByText('Data: 5')
})
it('loadable of a derived async atom with error does not trigger infinite loop (#1330)', async () => {
const baseAtom = atom(() => {
throw new Error('thrown in baseAtom')
})
const asyncAtom = atom(async (get) => {
get(baseAtom)
return ''
})
const { findByText, getByText } = render(
<StrictMode>
<LoadableComponent asyncAtom={asyncAtom} />
</StrictMode>,
)
getByText('Loading...')
await findByText('Error: thrown in baseAtom')
})
it('does not repeatedly attempt to get the value of an unresolved promise atom wrapped in a loadable (#1481)', async () => {
const baseAtom = atom(new Promise<number>(() => {}))
let callsToGetBaseAtom = 0
const derivedAtom = atom((get) => {
callsToGetBaseAtom++
return get(baseAtom)
})
render(
<StrictMode>
<LoadableComponent asyncAtom={derivedAtom} />
</StrictMode>,
)
// we need a small delay to reproduce the issue
await new Promise((r) => setTimeout(r, 10))
// depending on provider-less mode or versioned-write mode, there will be
// either 2 or 3 calls.
expect(callsToGetBaseAtom).toBeLessThanOrEqual(3)
})
it('should handle sync error (#1843)', async () => {
const syncAtom = atom(() => {
throw new Error('thrown in syncAtom')
})
const { findByText } = render(
<StrictMode>
<LoadableComponent asyncAtom={syncAtom} />
</StrictMode>,
)
await findByText('Error: thrown in syncAtom')
})
type LoadableComponentProps = {
asyncAtom: Atom<Promise<number> | Promise<string> | string | number>
effectCallback?: (loadableValue: any) => void
}
const LoadableComponent = ({
asyncAtom,
effectCallback,
}: LoadableComponentProps) => {
const value = useAtomValue(loadable(asyncAtom))
useEffect(() => {
if (effectCallback) {
effectCallback(value)
}
}, [value, effectCallback])
if (value.state === 'loading') {
return <>Loading...</>
}
if (value.state === 'hasError') {
return <>{String(value.error)}</>
}
// this is to ensure correct typing
const data: number | string = value.data
return <>Data: {data}</>
}
|
6,852 | 0 | petrpan-code/pmndrs/jotai/tests/react | petrpan-code/pmndrs/jotai/tests/react/vanilla-utils/selectAtom.test.tsx | import { StrictMode, Suspense, useEffect, useRef } from 'react'
import { fireEvent, render } from '@testing-library/react'
import { it } from 'vitest'
import { useAtom, useAtomValue, useSetAtom } from 'jotai/react'
import { atom } from 'jotai/vanilla'
import { selectAtom } from 'jotai/vanilla/utils'
const useCommitCount = () => {
const commitCountRef = useRef(1)
useEffect(() => {
commitCountRef.current += 1
})
return commitCountRef.current
}
it('selectAtom works as expected', async () => {
const bigAtom = atom({ a: 0, b: 'othervalue' })
const littleAtom = selectAtom(bigAtom, (v) => v.a)
const Parent = () => {
const setValue = useSetAtom(bigAtom)
return (
<>
<button
onClick={() =>
setValue((oldValue) => ({ ...oldValue, a: oldValue.a + 1 }))
}
>
increment
</button>
</>
)
}
const Selector = () => {
const a = useAtomValue(littleAtom)
return (
<>
<div>a: {a}</div>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Parent />
<Selector />
</StrictMode>,
)
await findByText('a: 0')
fireEvent.click(getByText('increment'))
await findByText('a: 1')
fireEvent.click(getByText('increment'))
await findByText('a: 2')
fireEvent.click(getByText('increment'))
await findByText('a: 3')
})
it('selectAtom works with async atom', async () => {
const bigAtom = atom({ a: 0, b: 'othervalue' })
const bigAtomAsync = atom((get) => Promise.resolve(get(bigAtom)))
const littleAtom = selectAtom(bigAtomAsync, (v) => v.a)
const Parent = () => {
const setValue = useSetAtom(bigAtom)
return (
<>
<button
onClick={() =>
setValue((oldValue) => ({ ...oldValue, a: oldValue.a + 1 }))
}
>
increment
</button>
</>
)
}
const Selector = () => {
const a = useAtomValue(littleAtom)
return (
<>
<div>a: {a}</div>
</>
)
}
const { findByText, getByText } = render(
<StrictMode>
<Suspense fallback={null}>
<Parent />
<Selector />
</Suspense>
</StrictMode>,
)
await findByText('a: 0')
fireEvent.click(getByText('increment'))
await findByText('a: 1')
fireEvent.click(getByText('increment'))
await findByText('a: 2')
fireEvent.click(getByText('increment'))
await findByText('a: 3')
})
it('do not update unless equality function says value has changed', async () => {
const bigAtom = atom({ a: 0 })
const littleAtom = selectAtom(
bigAtom,
(value) => value,
(left, right) => JSON.stringify(left) === JSON.stringify(right),
)
const Parent = () => {
const setValue = useSetAtom(bigAtom)
return (
<>
<button
onClick={() =>
setValue((oldValue) => ({ ...oldValue, a: oldValue.a + 1 }))
}
>
increment
</button>
<button onClick={() => setValue((oldValue) => ({ ...oldValue }))}>
copy
</button>
</>
)
}
const Selector = () => {
const value = useAtomValue(littleAtom)
const commits = useCommitCount()
return (
<>
<div>value: {JSON.stringify(value)}</div>
<div>commits: {commits}</div>
</>
)
}
const { findByText, getByText } = render(
<>
<Parent />
<Selector />
</>,
)
await findByText('value: {"a":0}')
await findByText('commits: 1')
fireEvent.click(getByText('copy'))
await findByText('value: {"a":0}')
await findByText('commits: 1')
fireEvent.click(getByText('increment'))
await findByText('value: {"a":1}')
await findByText('commits: 2')
fireEvent.click(getByText('copy'))
await findByText('value: {"a":1}')
await findByText('commits: 2')
fireEvent.click(getByText('increment'))
await findByText('value: {"a":2}')
await findByText('commits: 3')
fireEvent.click(getByText('copy'))
await findByText('value: {"a":2}')
await findByText('commits: 3')
fireEvent.click(getByText('increment'))
await findByText('value: {"a":3}')
await findByText('commits: 4')
fireEvent.click(getByText('copy'))
await findByText('value: {"a":3}')
await findByText('commits: 4')
})
it('equality function works even if suspend', async () => {
const bigAtom = atom({ a: 0 })
const bigAtomAsync = atom((get) => Promise.resolve(get(bigAtom)))
const littleAtom = selectAtom(
bigAtomAsync,
(value) => value,
(left, right) => left.a === right.a,
)
const Controls = () => {
const [value, setValue] = useAtom(bigAtom)
return (
<>
<div>bigValue: {JSON.stringify(value)}</div>
<button
onClick={() =>
setValue((oldValue) => ({ ...oldValue, a: oldValue.a + 1 }))
}
>
increment
</button>
<button onClick={() => setValue((oldValue) => ({ ...oldValue, b: 2 }))}>
other
</button>
</>
)
}
const Selector = () => {
const value = useAtomValue(littleAtom)
return <div>littleValue: {JSON.stringify(value)}</div>
}
const { findByText, getByText } = render(
<StrictMode>
<Suspense fallback={null}>
<Controls />
<Selector />
</Suspense>
</StrictMode>,
)
await findByText('bigValue: {"a":0}')
await findByText('littleValue: {"a":0}')
fireEvent.click(getByText('increment'))
await findByText('bigValue: {"a":1}')
await findByText('littleValue: {"a":1}')
fireEvent.click(getByText('other'))
await findByText('bigValue: {"a":1,"b":2}')
await findByText('littleValue: {"a":1}')
})
|
6,853 | 0 | petrpan-code/pmndrs/jotai/tests/react | petrpan-code/pmndrs/jotai/tests/react/vanilla-utils/splitAtom.test.tsx | import { StrictMode, useEffect, useRef } from 'react'
import { fireEvent, render, waitFor } from '@testing-library/react'
import { expect, it } from 'vitest'
import { useAtom, useAtomValue, useSetAtom } from 'jotai/react'
import { atom } from 'jotai/vanilla'
import type { Atom, PrimitiveAtom } from 'jotai/vanilla'
import { splitAtom } from 'jotai/vanilla/utils'
type TodoItem = { task: string; checked?: boolean }
const useCommitCount = () => {
const commitCountRef = useRef(1)
useEffect(() => {
commitCountRef.current += 1
})
return commitCountRef.current
}
it('no unnecessary updates when updating atoms', async () => {
const todosAtom = atom<TodoItem[]>([
{ task: 'get cat food', checked: false },
{ task: 'get dragon food', checked: false },
])
const TaskList = ({ listAtom }: { listAtom: typeof todosAtom }) => {
const [atoms, dispatch] = useAtom(splitAtom(listAtom))
return (
<>
TaskListUpdates: {useCommitCount()}
{atoms.map((anAtom) => (
<TaskItem
key={`${anAtom}`}
onRemove={() => dispatch({ type: 'remove', atom: anAtom })}
itemAtom={anAtom}
/>
))}
</>
)
}
const TaskItem = ({
itemAtom,
}: {
itemAtom: PrimitiveAtom<TodoItem>
onRemove: () => void
}) => {
const [value, onChange] = useAtom(itemAtom)
const toggle = () =>
onChange((value) => ({ ...value, checked: !value.checked }))
return (
<li>
{value.task} commits: {useCommitCount()}
<input
data-testid={`${value.task}-checkbox`}
type="checkbox"
checked={value.checked || false}
onChange={toggle}
/>
</li>
)
}
const { getByTestId, getByText } = render(
<>
<TaskList listAtom={todosAtom} />
</>,
)
await waitFor(() => {
getByText('TaskListUpdates: 1')
getByText('get cat food commits: 1')
getByText('get dragon food commits: 1')
})
const catBox = getByTestId('get cat food-checkbox') as HTMLInputElement
const dragonBox = getByTestId('get dragon food-checkbox') as HTMLInputElement
expect(catBox.checked).toBeFalsy()
expect(dragonBox.checked).toBeFalsy()
fireEvent.click(catBox)
await waitFor(() => {
getByText('TaskListUpdates: 1')
getByText('get cat food commits: 2')
getByText('get dragon food commits: 1')
})
expect(catBox.checked).toBeTruthy()
expect(dragonBox.checked).toBeFalsy()
fireEvent.click(dragonBox)
await waitFor(() => {
getByText('TaskListUpdates: 1')
getByText('get cat food commits: 2')
getByText('get dragon food commits: 2')
})
expect(catBox.checked).toBeTruthy()
expect(dragonBox.checked).toBeTruthy()
})
it('removing atoms', async () => {
const todosAtom = atom<TodoItem[]>([
{ task: 'get cat food', checked: false },
{ task: 'get dragon food', checked: false },
{ task: 'help nana', checked: false },
])
const TaskList = ({ listAtom }: { listAtom: typeof todosAtom }) => {
const [atoms, dispatch] = useAtom(splitAtom(listAtom))
return (
<>
{atoms.map((anAtom) => (
<TaskItem
key={`${anAtom}`}
onRemove={() => dispatch({ type: 'remove', atom: anAtom })}
itemAtom={anAtom}
/>
))}
</>
)
}
const TaskItem = ({
itemAtom,
onRemove,
}: {
itemAtom: PrimitiveAtom<TodoItem>
onRemove: () => void
}) => {
const [value] = useAtom(itemAtom)
return (
<li>
<div>{value.task}</div>
<button data-testid={`${value.task}-removebutton`} onClick={onRemove}>
X
</button>
</li>
)
}
const { getByTestId, queryByText } = render(
<StrictMode>
<TaskList listAtom={todosAtom} />
</StrictMode>,
)
await waitFor(() => {
expect(queryByText('get cat food')).toBeTruthy()
expect(queryByText('get dragon food')).toBeTruthy()
expect(queryByText('help nana')).toBeTruthy()
})
fireEvent.click(getByTestId('get cat food-removebutton'))
await waitFor(() => {
expect(queryByText('get cat food')).toBeFalsy()
expect(queryByText('get dragon food')).toBeTruthy()
expect(queryByText('help nana')).toBeTruthy()
})
fireEvent.click(getByTestId('get dragon food-removebutton'))
await waitFor(() => {
expect(queryByText('get cat food')).toBeFalsy()
expect(queryByText('get dragon food')).toBeFalsy()
expect(queryByText('help nana')).toBeTruthy()
})
fireEvent.click(getByTestId('help nana-removebutton'))
await waitFor(() => {
expect(queryByText('get cat food')).toBeFalsy()
expect(queryByText('get dragon food')).toBeFalsy()
expect(queryByText('help nana')).toBeFalsy()
})
})
it('inserting atoms', async () => {
const todosAtom = atom<TodoItem[]>([
{ task: 'get cat food' },
{ task: 'get dragon food' },
{ task: 'help nana' },
])
const TaskList = ({ listAtom }: { listAtom: typeof todosAtom }) => {
const [atoms, dispatch] = useAtom(splitAtom(listAtom))
return (
<>
<ul data-testid="list">
{atoms.map((anAtom) => (
<TaskItem
key={`${anAtom}`}
onInsert={(newValue) =>
dispatch({
type: 'insert',
value: newValue,
before: anAtom,
})
}
itemAtom={anAtom}
/>
))}
</ul>
<button
data-testid="addtaskbutton"
onClick={() =>
dispatch({
type: 'insert',
value: { task: 'end' },
})
}
>
add task
</button>
</>
)
}
let taskCount = 1
const TaskItem = ({
itemAtom,
onInsert,
}: {
itemAtom: PrimitiveAtom<TodoItem>
onInsert: (newValue: TodoItem) => void
}) => {
const [value] = useAtom(itemAtom)
return (
<li>
<div>{value.task}</div>
<button
data-testid={`${value.task}-insertbutton`}
onClick={() => onInsert({ task: 'new task' + taskCount++ })}
>
+
</button>
</li>
)
}
const { getByTestId, queryByTestId } = render(
<StrictMode>
<TaskList listAtom={todosAtom} />
</StrictMode>,
)
await waitFor(() => {
expect(queryByTestId('list')?.textContent).toBe(
'get cat food+get dragon food+help nana+',
)
})
fireEvent.click(getByTestId('help nana-insertbutton'))
await waitFor(() => {
expect(queryByTestId('list')?.textContent).toBe(
'get cat food+get dragon food+new task1+help nana+',
)
})
fireEvent.click(getByTestId('get cat food-insertbutton'))
await waitFor(() => {
expect(queryByTestId('list')?.textContent).toBe(
'new task2+get cat food+get dragon food+new task1+help nana+',
)
})
fireEvent.click(getByTestId('addtaskbutton'))
await waitFor(() => {
expect(queryByTestId('list')?.textContent).toBe(
'new task2+get cat food+get dragon food+new task1+help nana+end+',
)
})
})
it('moving atoms', async () => {
const todosAtom = atom<TodoItem[]>([
{ task: 'get cat food' },
{ task: 'get dragon food' },
{ task: 'help nana' },
])
const TaskList = ({ listAtom }: { listAtom: typeof todosAtom }) => {
const [atoms, dispatch] = useAtom(splitAtom(listAtom))
return (
<ul data-testid="list">
{atoms.map((anAtom, index) => (
<TaskItem
key={`${anAtom}`}
onMoveLeft={() => {
if (index === 0) {
dispatch({
type: 'move',
atom: anAtom,
})
} else if (index > 0) {
dispatch({
type: 'move',
atom: anAtom,
before: atoms[index - 1] as PrimitiveAtom<TodoItem>,
})
}
}}
onMoveRight={() => {
if (index === atoms.length - 1) {
dispatch({
type: 'move',
atom: anAtom,
})
} else if (index < atoms.length - 1) {
dispatch({
type: 'move',
atom: anAtom,
before: atoms[index + 2] as PrimitiveAtom<TodoItem>,
})
}
}}
itemAtom={anAtom}
/>
))}
</ul>
)
}
const TaskItem = ({
itemAtom,
onMoveLeft,
onMoveRight,
}: {
itemAtom: PrimitiveAtom<TodoItem>
onMoveLeft: () => void
onMoveRight: () => void
}) => {
const [value] = useAtom(itemAtom)
return (
<li>
<div>{value.task}</div>
<button data-testid={`${value.task}-leftbutton`} onClick={onMoveLeft}>
<
</button>
<button data-testid={`${value.task}-rightbutton`} onClick={onMoveRight}>
>
</button>
</li>
)
}
const { getByTestId, queryByTestId } = render(
<StrictMode>
<TaskList listAtom={todosAtom} />
</StrictMode>,
)
await waitFor(() => {
expect(queryByTestId('list')?.textContent).toBe(
'get cat food<>get dragon food<>help nana<>',
)
})
fireEvent.click(getByTestId('help nana-leftbutton'))
await waitFor(() => {
expect(queryByTestId('list')?.textContent).toBe(
'get cat food<>help nana<>get dragon food<>',
)
})
fireEvent.click(getByTestId('get cat food-rightbutton'))
await waitFor(() => {
expect(queryByTestId('list')?.textContent).toBe(
'help nana<>get cat food<>get dragon food<>',
)
})
fireEvent.click(getByTestId('get cat food-rightbutton'))
await waitFor(() => {
expect(queryByTestId('list')?.textContent).toBe(
'help nana<>get dragon food<>get cat food<>',
)
})
fireEvent.click(getByTestId('help nana-leftbutton'))
await waitFor(() => {
expect(queryByTestId('list')?.textContent).toBe(
'get dragon food<>get cat food<>help nana<>',
)
})
})
it('read-only array atom', async () => {
const todosAtom = atom<TodoItem[]>(() => [
{ task: 'get cat food', checked: false },
{ task: 'get dragon food', checked: false },
])
const TaskList = ({ listAtom }: { listAtom: typeof todosAtom }) => {
const [atoms] = useAtom(splitAtom(listAtom))
return (
<>
{atoms.map((anAtom) => (
<TaskItem key={`${anAtom}`} itemAtom={anAtom} />
))}
</>
)
}
const TaskItem = ({ itemAtom }: { itemAtom: Atom<TodoItem> }) => {
const [value] = useAtom(itemAtom)
return (
<li>
<input
data-testid={`${value.task}-checkbox`}
type="checkbox"
checked={value.checked || false}
readOnly
/>
</li>
)
}
const { getByTestId } = render(
<StrictMode>
<TaskList listAtom={todosAtom} />
</StrictMode>,
)
const catBox = getByTestId('get cat food-checkbox') as HTMLInputElement
const dragonBox = getByTestId('get dragon food-checkbox') as HTMLInputElement
await waitFor(() => {
expect(catBox.checked).toBeFalsy()
expect(dragonBox.checked).toBeFalsy()
})
})
it('no error with cached atoms (fix 510)', async () => {
const filterAtom = atom('all')
const numsAtom = atom<number[]>([0, 1, 2, 3, 4])
const filteredAtom = atom<number[]>((get) => {
const filter = get(filterAtom)
const nums = get(numsAtom)
if (filter === 'even') {
return nums.filter((num) => num % 2 === 0)
}
return nums
})
const filteredAtomsAtom = splitAtom(filteredAtom, (num) => num)
function useCachedAtoms<T>(atoms: T[]) {
const prevAtoms = useRef<T[]>(atoms)
return prevAtoms.current
}
type NumItemProps = { atom: Atom<number> }
const NumItem = ({ atom }: NumItemProps) => {
const [readOnlyItem] = useAtom(atom)
if (typeof readOnlyItem !== 'number') {
throw new Error('expecting a number')
}
return <>{readOnlyItem}</>
}
function Filter() {
const [, setFilter] = useAtom(filterAtom)
return <button onClick={() => setFilter('even')}>button</button>
}
const Filtered = () => {
const [todos] = useAtom(filteredAtomsAtom)
const cachedAtoms = useCachedAtoms(todos)
return (
<>
{cachedAtoms.map((atom) => (
<NumItem key={`${atom}`} atom={atom} />
))}
</>
)
}
const { getByText } = render(
<StrictMode>
<Filter />
<Filtered />
</StrictMode>,
)
fireEvent.click(getByText('button'))
})
it('variable sized splitted atom', async () => {
const lengthAtom = atom(3)
const collectionAtom = atom<number[]>([])
const collectionAtomsAtom = splitAtom(collectionAtom)
const derivativeAtom = atom((get) =>
get(collectionAtomsAtom).map((ca) => get(ca)),
)
function App() {
const [length, setLength] = useAtom(lengthAtom)
const setCollection = useSetAtom(collectionAtom)
const [derivative] = useAtom(derivativeAtom)
useEffect(() => {
setCollection([1, 2, 3].splice(0, length))
}, [length, setCollection])
return (
<div>
<button onClick={() => setLength(2)}>button</button>
numbers: {derivative.join(',')}
</div>
)
}
const { findByText, getByText } = render(
<StrictMode>
<App />
</StrictMode>,
)
await findByText('numbers: 1,2,3')
fireEvent.click(getByText('button'))
await findByText('numbers: 1,2')
})
it('should not update splitted atom when single item is set to identical value', async () => {
const initialCollection = [1, 2, 3]
const collectionAtom = atom<number[]>(initialCollection)
const collectionAtomsAtom = splitAtom(collectionAtom)
function App() {
const collectionAtoms = useAtomValue(collectionAtomsAtom)
const setItem2 = useSetAtom(collectionAtoms[1]!)
const currentCollection = useAtomValue(collectionAtom)
return (
<div>
<button onClick={() => setItem2(2)}>button</button>
changed: {(!Object.is(currentCollection, initialCollection)).toString()}
</div>
)
}
const { findByText, getByText } = render(
<StrictMode>
<App />
</StrictMode>,
)
await findByText('changed: false')
fireEvent.click(getByText('button'))
await findByText('changed: false')
})
|
6,854 | 0 | petrpan-code/pmndrs/jotai/tests | petrpan-code/pmndrs/jotai/tests/vanilla/basic.test.tsx | import { expect, it } from 'vitest'
import { atom } from 'jotai/vanilla'
it('creates atoms', () => {
// primitive atom
const countAtom = atom(0)
const anotherCountAtom = atom(1)
// read-only derived atom
const doubledCountAtom = atom((get) => get(countAtom) * 2)
// read-write derived atom
const sumCountAtom = atom(
(get) => get(countAtom) + get(anotherCountAtom),
(get, set, value: number) => {
set(countAtom, get(countAtom) + value / 2)
set(anotherCountAtom, get(anotherCountAtom) + value / 2)
},
)
// write-only derived atom
const decrementCountAtom = atom(null, (get, set) => {
set(countAtom, get(countAtom) - 1)
})
expect({
countAtom,
doubledCountAtom,
sumCountAtom,
decrementCountAtom,
}).toMatchInlineSnapshot(`
{
"countAtom": {
"init": 0,
"read": [Function],
"toString": [Function],
"write": [Function],
},
"decrementCountAtom": {
"init": null,
"read": [Function],
"toString": [Function],
"write": [Function],
},
"doubledCountAtom": {
"read": [Function],
"toString": [Function],
},
"sumCountAtom": {
"read": [Function],
"toString": [Function],
"write": [Function],
},
}
`)
})
it('should let users mark atoms as private', () => {
const internalAtom = atom(0)
internalAtom.debugPrivate = true
expect(internalAtom).toMatchInlineSnapshot(`
{
"debugPrivate": true,
"init": 0,
"read": [Function],
"toString": [Function],
"write": [Function],
}
`)
})
|
6,855 | 0 | petrpan-code/pmndrs/jotai/tests | petrpan-code/pmndrs/jotai/tests/vanilla/dependency.test.tsx | import { expect, it } from 'vitest'
import { atom, createStore } from 'jotai/vanilla'
it('can propagate updates with async atom chains', async () => {
const store = createStore()
const countAtom = atom(1)
let resolve = () => {}
const asyncAtom = atom(async (get) => {
const count = get(countAtom)
await new Promise<void>((r) => (resolve = r))
return count
})
const async2Atom = atom((get) => get(asyncAtom))
const async3Atom = atom((get) => get(async2Atom))
expect(store.get(async3Atom) instanceof Promise).toBeTruthy()
resolve()
await expect(store.get(async3Atom)).resolves.toBe(1)
store.set(countAtom, (c) => c + 1)
expect(store.get(async3Atom) instanceof Promise).toBeTruthy()
resolve()
await expect(store.get(async3Atom)).resolves.toBe(2)
store.set(countAtom, (c) => c + 1)
expect(store.get(async3Atom) instanceof Promise).toBeTruthy()
resolve()
await expect(store.get(async3Atom)).resolves.toBe(3)
})
it('can get async atom with deps more than once before resolving (#1668)', async () => {
const countAtom = atom(0)
const resolve: (() => void)[] = []
const asyncAtom = atom(async (get) => {
const count = get(countAtom)
await new Promise<void>((r) => resolve.push(r))
return count
})
const store = createStore()
store.set(countAtom, (c) => c + 1)
store.get(asyncAtom)
store.set(countAtom, (c) => c + 1)
const promise = store.get(asyncAtom)
resolve.shift()?.()
await Promise.resolve()
resolve.shift()?.()
const count = await promise
expect(count).toBe(2)
})
it('correctly updates async derived atom after get/set update', async () => {
const baseAtom = atom(0)
const derivedAsyncAtom = atom(
async (get) => get(baseAtom) + 1,
async (_get, set, val) => set(baseAtom, val as number),
)
const store = createStore()
// NOTE: Have to .set() straight after await on .get(), so that it executes
// in the same JS event loop cycle!
let derived = await store.get(derivedAsyncAtom)
await store.set(derivedAsyncAtom, 2)
expect(derived).toBe(1)
expect(store.get(baseAtom)).toBe(2)
derived = await store.get(derivedAsyncAtom)
expect(derived).toBe(3)
})
it('correctly handles the same promise being returned twice from an atom getter (#2151)', async () => {
const asyncDataAtom = atom(async () => {
return 'Asynchronous Data'
})
const counterAtom = atom(0)
const derivedAtom = atom((get) => {
get(counterAtom) // depending on sync data
return get(asyncDataAtom) // returning a promise from another atom
})
const store = createStore()
store.get(derivedAtom)
// setting the `counterAtom` dependency on the same JS event loop cycle, before
// the `derivedAtom` promise resolves.
store.set(counterAtom, 1)
await expect(store.get(derivedAtom)).resolves.toBe('Asynchronous Data')
})
|
6,856 | 0 | petrpan-code/pmndrs/jotai/tests | petrpan-code/pmndrs/jotai/tests/vanilla/store.test.tsx | import { waitFor } from '@testing-library/dom'
import { assert, describe, expect, it, vi } from 'vitest'
import { atom, createStore } from 'jotai/vanilla'
import type { Getter } from 'jotai/vanilla'
it('should not fire on subscribe', async () => {
const store = createStore()
const countAtom = atom(0)
const callback1 = vi.fn()
const callback2 = vi.fn()
store.sub(countAtom, callback1)
store.sub(countAtom, callback2)
expect(callback1).not.toHaveBeenCalled()
expect(callback2).not.toHaveBeenCalled()
})
it('should not fire subscription if primitive atom value is the same', async () => {
const store = createStore()
const countAtom = atom(0)
const callback = vi.fn()
store.sub(countAtom, callback)
const calledTimes = callback.mock.calls.length
store.set(countAtom, 0)
expect(callback).toHaveBeenCalledTimes(calledTimes)
})
it('should not fire subscription if derived atom value is the same', async () => {
const store = createStore()
const countAtom = atom(0)
const derivedAtom = atom((get) => get(countAtom) * 0)
const callback = vi.fn()
store.sub(derivedAtom, callback)
const calledTimes = callback.mock.calls.length
store.set(countAtom, 1)
expect(callback).toHaveBeenCalledTimes(calledTimes)
})
describe('[DEV-ONLY] dev-only methods', () => {
it('should return the values of all mounted atoms', () => {
const store = createStore()
const countAtom = atom(0)
countAtom.debugLabel = 'countAtom'
const derivedAtom = atom((get) => get(countAtom) * 0)
const unsub = store.sub(derivedAtom, vi.fn())
store.set(countAtom, 1)
const result = store.dev_get_mounted_atoms?.() || []
expect(Array.from(result)).toStrictEqual([
{ toString: expect.any(Function), read: expect.any(Function) },
{
toString: expect.any(Function),
init: 0,
read: expect.any(Function),
write: expect.any(Function),
debugLabel: 'countAtom',
},
])
unsub()
})
it('should get atom state of a given atom', () => {
const store = createStore()
const countAtom = atom(0)
countAtom.debugLabel = 'countAtom'
const unsub = store.sub(countAtom, vi.fn())
store.set(countAtom, 1)
const result = store.dev_get_atom_state?.(countAtom)
expect(result).toHaveProperty('v', 1)
unsub()
})
it('should get mounted atom from mounted map', () => {
const store = createStore()
const countAtom = atom(0)
countAtom.debugLabel = 'countAtom'
const cb = vi.fn()
const unsub = store.sub(countAtom, cb)
store.set(countAtom, 1)
const result = store.dev_get_mounted?.(countAtom)
expect(result).toStrictEqual({ l: new Set([cb]), t: new Set([countAtom]) })
unsub()
})
it('should restore atoms and its dependencies correctly', () => {
const store = createStore()
const countAtom = atom(0)
countAtom.debugLabel = 'countAtom'
const derivedAtom = atom((get) => get(countAtom) * 2)
store.set(countAtom, 1)
store.dev_restore_atoms?.([[countAtom, 2]])
expect(store.get(countAtom)).toBe(2)
expect(store.get?.(derivedAtom)).toBe(4)
})
describe('dev_subscribe_store rev2', () => {
it('should call the callback when state changes', () => {
const store = createStore()
const callback = vi.fn()
const unsub = store.dev_subscribe_store?.(callback, 2)
const countAtom = atom(0)
const unsubAtom = store.sub(countAtom, vi.fn())
store.set(countAtom, 1)
expect(callback).toHaveBeenNthCalledWith(1, {
type: 'sub',
flushed: new Set([countAtom]),
})
expect(callback).toHaveBeenNthCalledWith(2, {
type: 'write',
flushed: new Set([countAtom]),
})
expect(callback).toHaveBeenCalledTimes(2)
unsub?.()
unsubAtom?.()
})
it('should call unsub only when atom is unsubscribed', () => {
const store = createStore()
const callback = vi.fn()
const unsub = store.dev_subscribe_store?.(callback, 2)
const countAtom = atom(0)
const unsubAtom = store.sub(countAtom, vi.fn())
const unsubAtomSecond = store.sub(countAtom, vi.fn())
unsubAtom?.()
expect(callback).toHaveBeenNthCalledWith(1, {
type: 'sub',
flushed: new Set([countAtom]),
})
expect(callback).toHaveBeenNthCalledWith(2, {
type: 'sub',
flushed: new Set(),
})
expect(callback).toHaveBeenNthCalledWith(3, { type: 'unsub' })
expect(callback).toHaveBeenCalledTimes(3)
unsub?.()
unsubAtomSecond?.()
})
})
it('should unmount tree dependencies with store.get', async () => {
const store = createStore()
const countAtom = atom(0)
const derivedAtom = atom((get) => get(countAtom) * 2)
const anotherDerivedAtom = atom((get) => get(countAtom) * 3)
const callback = vi.fn()
const unsubStore = store.dev_subscribe_store?.(() => {
// Comment this line to make the test pass
store.get(derivedAtom)
}, 2)
const unsub = store.sub(anotherDerivedAtom, callback)
unsub()
unsubStore?.()
const result = Array.from(store.dev_get_mounted_atoms?.() ?? [])
expect(result).toEqual([])
})
})
it('should unmount with store.get', async () => {
const store = createStore()
const countAtom = atom(0)
const callback = vi.fn()
const unsub = store.sub(countAtom, callback)
store.get(countAtom)
unsub()
const result = Array.from(store.dev_get_mounted_atoms?.() ?? [])
expect(result).toEqual([])
})
it('should unmount dependencies with store.get', async () => {
const store = createStore()
const countAtom = atom(0)
const derivedAtom = atom((get) => get(countAtom) * 2)
const callback = vi.fn()
const unsub = store.sub(derivedAtom, callback)
store.get(derivedAtom)
unsub()
const result = Array.from(store.dev_get_mounted_atoms?.() ?? [])
expect(result).toEqual([])
})
it('should update async atom with delay (#1813)', async () => {
const countAtom = atom(0)
const resolve: (() => void)[] = []
const delayedAtom = atom(async (get) => {
const count = get(countAtom)
await new Promise<void>((r) => resolve.push(r))
return count
})
const store = createStore()
store.get(delayedAtom)
store.set(countAtom, 1)
resolve.splice(0).forEach((fn) => fn())
await new Promise<void>((r) => setTimeout(r)) // wait for a tick
const promise = store.get(delayedAtom)
resolve.splice(0).forEach((fn) => fn())
expect(await promise).toBe(1)
})
it('should override a promise by setting', async () => {
const store = createStore()
const countAtom = atom(Promise.resolve(0))
const infinitePending = new Promise<never>(() => {})
store.set(countAtom, infinitePending)
const promise = store.get(countAtom)
store.set(countAtom, Promise.resolve(1))
expect(await promise).toBe(1)
})
it('should update async atom with deps after await (#1905)', async () => {
const countAtom = atom(0)
const resolve: (() => void)[] = []
const delayedAtom = atom(async (get) => {
await new Promise<void>((r) => resolve.push(r))
const count = get(countAtom)
return count
})
const derivedAtom = atom(async (get) => {
const count = await get(delayedAtom)
return count
})
const store = createStore()
let lastValue = store.get(derivedAtom)
const unsub = store.sub(derivedAtom, () => {
lastValue = store.get(derivedAtom)
})
store.set(countAtom, 1)
resolve.splice(0).forEach((fn) => fn())
expect(await lastValue).toBe(1)
store.set(countAtom, 2)
resolve.splice(0).forEach((fn) => fn())
expect(await lastValue).toBe(2)
store.set(countAtom, 3)
resolve.splice(0).forEach((fn) => fn())
expect(await lastValue).toBe(3)
unsub()
})
it('should not fire subscription when async atom promise is the same', async () => {
const promise = Promise.resolve()
const promiseAtom = atom(promise)
const derivedGetter = vi.fn((get: Getter) => get(promiseAtom))
const derivedAtom = atom(derivedGetter)
const store = createStore()
expect(derivedGetter).not.toHaveBeenCalled()
const promiseListener = vi.fn()
const promiseUnsub = store.sub(promiseAtom, promiseListener)
const derivedListener = vi.fn()
const derivedUnsub = store.sub(derivedAtom, derivedListener)
expect(derivedGetter).toHaveBeenCalledOnce()
expect(promiseListener).not.toHaveBeenCalled()
expect(derivedListener).not.toHaveBeenCalled()
store.get(promiseAtom)
store.get(derivedAtom)
expect(derivedGetter).toHaveBeenCalledOnce()
expect(promiseListener).not.toHaveBeenCalled()
expect(derivedListener).not.toHaveBeenCalled()
store.set(promiseAtom, promise)
expect(derivedGetter).toHaveBeenCalledOnce()
expect(promiseListener).not.toHaveBeenCalled()
expect(derivedListener).not.toHaveBeenCalled()
store.set(promiseAtom, promise)
expect(derivedGetter).toHaveBeenCalledOnce()
expect(promiseListener).not.toHaveBeenCalled()
expect(derivedListener).not.toHaveBeenCalled()
promiseUnsub()
derivedUnsub()
})
it('should notify subscription with tree dependencies (#1956)', async () => {
const valueAtom = atom(1)
const dep1Atom = atom((get) => get(valueAtom) * 2)
const dep2Atom = atom((get) => get(valueAtom) + get(dep1Atom))
const dep3Atom = atom((get) => get(dep1Atom))
const cb = vi.fn()
const store = createStore()
store.sub(dep2Atom, vi.fn()) // this will cause the bug
store.sub(dep3Atom, cb)
expect(cb).toBeCalledTimes(0)
expect(store.get(dep3Atom)).toBe(2)
store.set(valueAtom, (c) => c + 1)
expect(cb).toBeCalledTimes(1)
expect(store.get(dep3Atom)).toBe(4)
})
it('should notify subscription with tree dependencies with bail-out', async () => {
const valueAtom = atom(1)
const dep1Atom = atom((get) => get(valueAtom) * 2)
const dep2Atom = atom((get) => get(valueAtom) * 0)
const dep3Atom = atom((get) => get(dep1Atom) + get(dep2Atom))
const cb = vi.fn()
const store = createStore()
store.sub(dep1Atom, vi.fn())
store.sub(dep3Atom, cb)
expect(cb).toBeCalledTimes(0)
expect(store.get(dep3Atom)).toBe(2)
store.set(valueAtom, (c) => c + 1)
expect(cb).toBeCalledTimes(1)
expect(store.get(dep3Atom)).toBe(4)
})
it('should bail out with the same value with chained dependency (#2014)', async () => {
const store = createStore()
const objAtom = atom({ count: 1 })
const countAtom = atom((get) => get(objAtom).count)
const deriveFn = vi.fn((get: Getter) => get(countAtom))
const derivedAtom = atom(deriveFn)
const deriveFurtherFn = vi.fn((get: Getter) => {
get(objAtom) // intentional extra dependency
return get(derivedAtom)
})
const derivedFurtherAtom = atom(deriveFurtherFn)
const callback = vi.fn()
store.sub(derivedFurtherAtom, callback)
expect(store.get(derivedAtom)).toBe(1)
expect(store.get(derivedFurtherAtom)).toBe(1)
expect(callback).toHaveBeenCalledTimes(0)
expect(deriveFn).toHaveBeenCalledTimes(1)
expect(deriveFurtherFn).toHaveBeenCalledTimes(1)
store.set(objAtom, (obj) => ({ ...obj }))
expect(callback).toHaveBeenCalledTimes(0)
expect(deriveFn).toHaveBeenCalledTimes(1)
expect(deriveFurtherFn).toHaveBeenCalledTimes(2)
})
it('should not call read function for unmounted atoms (#2076)', async () => {
const store = createStore()
const countAtom = atom(1)
const derive1Fn = vi.fn((get: Getter) => get(countAtom))
const derived1Atom = atom(derive1Fn)
const derive2Fn = vi.fn((get: Getter) => get(countAtom))
const derived2Atom = atom(derive2Fn)
expect(store.get(derived1Atom)).toBe(1)
expect(store.get(derived2Atom)).toBe(1)
expect(derive1Fn).toHaveBeenCalledTimes(1)
expect(derive2Fn).toHaveBeenCalledTimes(1)
store.sub(derived2Atom, vi.fn())
store.set(countAtom, (c) => c + 1)
expect(derive1Fn).toHaveBeenCalledTimes(1)
expect(derive2Fn).toHaveBeenCalledTimes(2)
})
it('should update with conditional dependencies (#2084)', async () => {
const store = createStore()
const f1 = atom(false)
const f2 = atom(false)
const f3 = atom(
(get) => get(f1) && get(f2),
(_get, set, val: boolean) => {
set(f1, val)
set(f2, val)
},
)
store.sub(f1, vi.fn())
store.sub(f2, vi.fn())
store.sub(f3, vi.fn())
store.set(f3, true)
expect(store.get(f3)).toBe(true)
})
it("should recompute dependents' state after onMount (#2098)", async () => {
const store = createStore()
const condAtom = atom(false)
const baseAtom = atom(false)
baseAtom.onMount = (set) => set(true)
const derivedAtom = atom(
(get) => get(baseAtom),
(_get, set, update: boolean) => set(baseAtom, update),
)
const finalAtom = atom(
(get) => (get(condAtom) ? get(derivedAtom) : undefined),
(_get, set, value: boolean) => set(derivedAtom, value),
)
store.sub(finalAtom, () => {}) // mounts finalAtom, but not baseAtom
expect(store.get(baseAtom)).toBe(false)
expect(store.get(derivedAtom)).toBe(false)
expect(store.get(finalAtom)).toBe(undefined)
store.set(condAtom, true) // mounts baseAtom
expect(store.get(baseAtom)).toBe(true)
expect(store.get(derivedAtom)).toBe(true)
expect(store.get(finalAtom)).toBe(true)
store.set(finalAtom, false)
expect(store.get(baseAtom)).toBe(false)
expect(store.get(derivedAtom)).toBe(false)
expect(store.get(finalAtom)).toBe(false)
})
it('should update derived atoms during write (#2107)', async () => {
const store = createStore()
const baseCountAtom = atom(1)
const countAtom = atom(
(get) => get(baseCountAtom),
(get, set, newValue: number) => {
set(baseCountAtom, newValue)
if (get(countAtom) !== newValue) {
throw new Error('mismatch')
}
},
)
store.sub(countAtom, () => {})
expect(store.get(countAtom)).toBe(1)
store.set(countAtom, 2)
expect(store.get(countAtom)).toBe(2)
})
it('resolves dependencies reliably after a delay (#2192)', async () => {
expect.assertions(1)
const countAtom = atom(0)
let result: number | null = null
const resolve: (() => void)[] = []
const asyncAtom = atom(async (get) => {
const count = get(countAtom)
await new Promise<void>((r) => resolve.push(r))
return count
})
const derivedAtom = atom(
async (get, { setSelf }) => {
get(countAtom)
await Promise.resolve()
result = await get(asyncAtom)
if (result === 2) setSelf() // <-- necessary
},
() => {},
)
const store = createStore()
store.sub(derivedAtom, () => {})
await waitFor(() => assert(resolve.length === 1))
resolve[0]!()
const increment = (c: number) => c + 1
store.set(countAtom, increment)
store.set(countAtom, increment)
await waitFor(() => assert(resolve.length === 3))
resolve[1]!()
resolve[2]!()
await waitFor(() => assert(result === 2))
store.set(countAtom, increment)
store.set(countAtom, increment)
await waitFor(() => assert(resolve.length === 5))
resolve[3]!()
resolve[4]!()
await new Promise(setImmediate)
await waitFor(() => assert(store.get(countAtom) === 4))
expect(result).toBe(4) // 3
})
it('should not recompute a derived atom value if unchanged (#2168)', async () => {
const store = createStore()
const countAtom = atom(1)
const derived1Atom = atom((get) => get(countAtom) * 0)
const derive2Fn = vi.fn((get: Getter) => get(derived1Atom))
const derived2Atom = atom(derive2Fn)
expect(store.get(derived2Atom)).toBe(0)
store.set(countAtom, (c) => c + 1)
expect(store.get(derived2Atom)).toBe(0)
expect(derive2Fn).toHaveBeenCalledTimes(1)
})
|
6,857 | 0 | petrpan-code/pmndrs/jotai/tests | petrpan-code/pmndrs/jotai/tests/vanilla/types.test.tsx | import { expectType } from 'ts-expect'
import { it } from 'vitest'
import { atom } from 'jotai/vanilla'
import type {
Atom,
ExtractAtomArgs,
ExtractAtomResult,
ExtractAtomValue,
PrimitiveAtom,
WritableAtom,
} from 'jotai/vanilla'
it('atom() should return the correct types', () => {
function Component() {
// primitive atom
const primitiveAtom = atom(0)
expectType<PrimitiveAtom<number>>(primitiveAtom)
// read-only derived atom
const readonlyDerivedAtom = atom((get) => get(primitiveAtom) * 2)
expectType<Atom<number>>(readonlyDerivedAtom)
// read-write derived atom
const readWriteDerivedAtom = atom(
(get) => get(primitiveAtom),
(get, set, value: number) => {
set(primitiveAtom, get(primitiveAtom) + value)
},
)
expectType<WritableAtom<number, [number], void>>(readWriteDerivedAtom)
// write-only derived atom
const writeonlyDerivedAtom = atom(null, (get, set) => {
set(primitiveAtom, get(primitiveAtom) - 1)
})
expectType<WritableAtom<null, [], void>>(writeonlyDerivedAtom)
}
Component
})
it('type utils should work', () => {
function Component() {
const readWriteAtom = atom(
(_get) => 1 as number,
async (_get, _set, _value: string) => {},
)
const value: ExtractAtomValue<typeof readWriteAtom> = 1
expectType<number>(value)
const args: ExtractAtomArgs<typeof readWriteAtom> = ['']
expectType<[string]>(args)
const result: ExtractAtomResult<typeof readWriteAtom> = Promise.resolve()
expectType<Promise<void>>(result)
}
Component
})
|
6,858 | 0 | petrpan-code/pmndrs/jotai/tests/vanilla | petrpan-code/pmndrs/jotai/tests/vanilla/utils/types.test.tsx | import { expectType } from 'ts-expect'
import type { TypeEqual } from 'ts-expect'
import { it } from 'vitest'
import { atom } from 'jotai/vanilla'
import type { Atom, SetStateAction, WritableAtom } from 'jotai/vanilla'
import { selectAtom, unwrap } from 'jotai/vanilla/utils'
it('selectAtom() should return the correct types', () => {
const doubleCount = (x: number) => x * 2
const syncAtom = atom(0)
const syncSelectedAtom = selectAtom(syncAtom, doubleCount)
expectType<TypeEqual<Atom<number>, typeof syncSelectedAtom>>(true)
const asyncAtom = atom(Promise.resolve(0))
const asyncSelectedAtom = selectAtom(asyncAtom, doubleCount)
expectType<TypeEqual<Atom<Promise<number>>, typeof asyncSelectedAtom>>(true)
const maybeAsyncAtom = atom(Promise.resolve(0) as number | Promise<number>)
const maybeAsyncSelectedAtom = selectAtom(maybeAsyncAtom, doubleCount)
expectType<
TypeEqual<Atom<number | Promise<number>>, typeof maybeAsyncSelectedAtom>
>(true)
})
it('unwrap() should return the correct types', () => {
const getFallbackValue = () => -1
const syncAtom = atom(0)
const syncUnwrappedAtom = unwrap(syncAtom, getFallbackValue)
expectType<
TypeEqual<
WritableAtom<number, [SetStateAction<number>], void>,
typeof syncUnwrappedAtom
>
>(true)
const asyncAtom = atom(Promise.resolve(0))
const asyncUnwrappedAtom = unwrap(asyncAtom, getFallbackValue)
expectType<
TypeEqual<
WritableAtom<number, [SetStateAction<Promise<number>>], void>,
typeof asyncUnwrappedAtom
>
>(true)
const maybeAsyncAtom = atom(Promise.resolve(0) as number | Promise<number>)
const maybeAsyncUnwrappedAtom = unwrap(maybeAsyncAtom, getFallbackValue)
expectType<
TypeEqual<
WritableAtom<number, [SetStateAction<number | Promise<number>>], void>,
typeof maybeAsyncUnwrappedAtom
>
>(true)
})
|
6,859 | 0 | petrpan-code/pmndrs/jotai/tests/vanilla | petrpan-code/pmndrs/jotai/tests/vanilla/utils/unwrap.test.ts | import { describe, expect, it } from 'vitest'
import { atom, createStore } from 'jotai/vanilla'
import { unwrap } from 'jotai/vanilla/utils'
describe('unwrap', () => {
it('should unwrap a promise with no fallback function', async () => {
const store = createStore()
const countAtom = atom(1)
let resolve = () => {}
const asyncAtom = atom(async (get) => {
const count = get(countAtom)
await new Promise<void>((r) => (resolve = r))
return count * 2
})
const syncAtom = unwrap(asyncAtom)
expect(store.get(syncAtom)).toBe(undefined)
resolve()
await new Promise((r) => setTimeout(r)) // wait for a tick
expect(store.get(syncAtom)).toBe(2)
store.set(countAtom, 2)
expect(store.get(syncAtom)).toBe(undefined)
resolve()
await new Promise((r) => setTimeout(r)) // wait for a tick
expect(store.get(syncAtom)).toBe(4)
store.set(countAtom, 3)
expect(store.get(syncAtom)).toBe(undefined)
resolve()
await new Promise((r) => setTimeout(r)) // wait for a tick
expect(store.get(syncAtom)).toBe(6)
})
it('should unwrap a promise with fallback function without prev', async () => {
const store = createStore()
const countAtom = atom(1)
let resolve = () => {}
const asyncAtom = atom(async (get) => {
const count = get(countAtom)
await new Promise<void>((r) => (resolve = r))
return count * 2
})
const syncAtom = unwrap(asyncAtom, () => -1)
expect(store.get(syncAtom)).toBe(-1)
resolve()
await new Promise((r) => setTimeout(r)) // wait for a tick
expect(store.get(syncAtom)).toBe(2)
store.set(countAtom, 2)
expect(store.get(syncAtom)).toBe(-1)
resolve()
await new Promise((r) => setTimeout(r)) // wait for a tick
expect(store.get(syncAtom)).toBe(4)
store.set(countAtom, 3)
expect(store.get(syncAtom)).toBe(-1)
resolve()
await new Promise((r) => setTimeout(r)) // wait for a tick
expect(store.get(syncAtom)).toBe(6)
})
it('should unwrap a promise with fallback function with prev', async () => {
const store = createStore()
const countAtom = atom(1)
let resolve = () => {}
const asyncAtom = atom(async (get) => {
const count = get(countAtom)
await new Promise<void>((r) => (resolve = r))
return count * 2
})
const syncAtom = unwrap(asyncAtom, (prev?: number) => prev ?? 0)
expect(store.get(syncAtom)).toBe(0)
resolve()
await new Promise((r) => setTimeout(r)) // wait for a tick
expect(store.get(syncAtom)).toBe(2)
store.set(countAtom, 2)
expect(store.get(syncAtom)).toBe(2)
resolve()
await new Promise((r) => setTimeout(r)) // wait for a tick
expect(store.get(syncAtom)).toBe(4)
store.set(countAtom, 3)
expect(store.get(syncAtom)).toBe(4)
resolve()
await new Promise((r) => setTimeout(r)) // wait for a tick
expect(store.get(syncAtom)).toBe(6)
store.set(countAtom, 4)
expect(store.get(syncAtom)).toBe(6)
resolve()
store.set(countAtom, 5)
expect(store.get(syncAtom)).not.toBe(0) // expect 6 or 8
resolve()
await new Promise((r) => setTimeout(r)) // wait for a tick
expect(store.get(syncAtom)).toBe(10)
})
it('should unwrap a sync atom which is noop', async () => {
const store = createStore()
const countAtom = atom(1)
const syncAtom = unwrap(countAtom)
expect(store.get(syncAtom)).toBe(1)
store.set(countAtom, 2)
expect(store.get(syncAtom)).toBe(2)
store.set(countAtom, 3)
expect(store.get(syncAtom)).toBe(3)
})
it('should unwrap an async writable atom', async () => {
const store = createStore()
const asyncAtom = atom(Promise.resolve(1))
const syncAtom = unwrap(asyncAtom, (prev?: number) => prev ?? 0)
expect(store.get(syncAtom)).toBe(0)
await new Promise((r) => setTimeout(r)) // wait for a tick
expect(store.get(syncAtom)).toBe(1)
store.set(syncAtom, Promise.resolve(2))
expect(store.get(syncAtom)).toBe(1)
await new Promise((r) => setTimeout(r)) // wait for a tick
expect(store.get(syncAtom)).toBe(2)
store.set(syncAtom, Promise.resolve(3))
expect(store.get(syncAtom)).toBe(2)
await new Promise((r) => setTimeout(r)) // wait for a tick
expect(store.get(syncAtom)).toBe(3)
})
})
|
7,209 | 0 | petrpan-code/pmndrs/use-gesture/packages/react | petrpan-code/pmndrs/use-gesture/packages/react/src/types.test.ts | /* eslint-disable react-hooks/rules-of-hooks */
/* Type tests for @use-gesture/react */
import { useRef } from 'react'
import { expectType } from 'tsd'
import { useDrag, useGesture } from '.'
import { ReactDOMAttributes } from './types'
/* Checks that gesture hooks return event props handlers */
expectType<(...args: any[]) => ReactDOMAttributes>(useDrag(() => {}))
/* Checks that gesture hooks don't return any value when used with config option `target` */
expectType<void>(useDrag(() => {}, { target: window }))
/* Checks that hooks accept generics to cast event type */
useDrag<MouseEvent>(({ event }) => expectType<MouseEvent>(event))
const fakeDiv = 'fake' as any as HTMLDivElement
const fakeRef = useRef<HTMLDivElement>(null)
/* Checks config.bounds type for useDrag */
useDrag(() => {}, { bounds: { left: 0 } })
useDrag(() => {}, { bounds: fakeDiv })
useDrag(() => {}, { bounds: fakeRef })
/* Checks that useGesture returns event props handler */
expectType<(...args: any[]) => ReactDOMAttributes>(useGesture({ onPinch: () => {} }))
/* Checks that useGesture doesn't return any value when used with config option `target` */
expectType<void>(useGesture({ onPinch: () => {} }, { target: window }))
/* Checks that useGesture accepts generics to cast event type */
useGesture<{ drag: MouseEvent; pinch: WheelEvent; onClick: PointerEvent }>({
onDrag: ({ event }) => expectType<MouseEvent>(event),
onPinch: ({ event }) => expectType<WheelEvent>(event),
onClick: ({ event }) => expectType<PointerEvent>(event)
})
|
7,232 | 0 | petrpan-code/pmndrs/use-gesture/packages/vanilla | petrpan-code/pmndrs/use-gesture/packages/vanilla/src/types.test.ts | /* Type tests for @use-gesture/vanilla */
import { expectType } from 'tsd'
import { DragGesture, Gesture } from '.'
/* Checks that hooks accept generics to cast event type */
new DragGesture<MouseEvent>(window, ({ event }) => expectType<MouseEvent>(event))
/* Checks that useGesture accepts generics to cast event type */
new Gesture<{ drag: MouseEvent; pinch: WheelEvent; onClick: PointerEvent }>(window, {
onDrag: ({ event }) => expectType<MouseEvent>(event),
onPinch: ({ event }) => expectType<WheelEvent>(event),
onClick: ({ event }) => expectType<PointerEvent>(event)
})
|
7,233 | 0 | petrpan-code/pmndrs/use-gesture | petrpan-code/pmndrs/use-gesture/test/api.test.tsx | import React from 'react'
import { render, cleanup, fireEvent, createEvent } from '@testing-library/react'
import { patchCreateEvent } from './utils'
import '@testing-library/jest-dom/extend-expect'
import { BindProps, GenuineHandlers } from './components/Api'
import Interactive from './components/Interactive'
import InteractiveDom from './components/InteractiveDom'
afterEach(cleanup)
patchCreateEvent(createEvent)
test('bind should dispatch its arguments', () => {
const { getByTestId } = render(<BindProps args1={['args1']} args2={['args2']} />)
const firstElement = getByTestId('drag-el')
const secondElement = getByTestId('2-drag-el')
fireEvent.pointerDown(firstElement, { pointerId: 1, buttons: 1 })
expect(getByTestId('drag-args')).toHaveTextContent('args1')
fireEvent.pointerUp(firstElement, { pointerId: 1 })
expect(getByTestId('drag-args')).toHaveTextContent('args1')
fireEvent.pointerDown(secondElement, { pointerId: 2, buttons: 1 })
expect(getByTestId('2-drag-args')).toHaveTextContent('args2')
fireEvent.pointerUp(secondElement, { pointerId: 2 })
expect(getByTestId('2-drag-args')).toHaveTextContent('args2')
fireEvent.pointerDown(firstElement, { pointerId: 3, buttons: 1 })
expect(getByTestId('drag-args')).toHaveTextContent('args1')
fireEvent.pointerUp(firstElement, { pointerId: 3 })
expect(getByTestId('drag-args')).toHaveTextContent('args1')
})
test('native handlers should correctly execute', () => {
const { getByTestId } = render(<GenuineHandlers args="testArg" />)
const element = getByTestId('drag-el')
fireEvent.pointerDown(element, { pointerId: 4, buttons: 1 })
expect(getByTestId('drag-active')).toHaveTextContent('true')
expect(getByTestId('mouseDown')).toHaveTextContent('mouse down')
fireEvent.pointerUp(element, { pointerId: 4 })
fireEvent.click(element)
expect(getByTestId('click')).toHaveTextContent(/^clicked testArg$/)
})
test('testing memo', () => {
const { getByTestId, rerender } = render(<Interactive gestures={['Drag']} memoArg="memo" />)
const element = getByTestId('drag-el')
fireEvent.pointerDown(element, { pointerId: 5, buttons: 1 })
expect(getByTestId('drag-memo')).toHaveTextContent('memo')
fireEvent.pointerUp(element, { pointerId: 5 })
rerender(<Interactive gestures={['Drag']} memoArg={0} />)
fireEvent.pointerDown(element, { pointerId: 6, buttons: 1 })
expect(getByTestId('drag-memo')).toHaveTextContent('0')
fireEvent.pointerUp(element, { pointerId: 6 })
rerender(<Interactive gestures={['Drag']} memoArg={null} />)
fireEvent.pointerDown(element, { pointerId: 7, buttons: 1 })
expect(getByTestId('drag-memo')).toHaveTextContent('null')
fireEvent.pointerUp(element, { pointerId: 7 })
rerender(<Interactive gestures={['Drag']} memoArg={''} />)
fireEvent.pointerDown(element, { pointerId: 8, buttons: 1 })
expect(getByTestId('drag-memo')).toHaveTextContent(/^$/)
fireEvent.pointerUp(element, { pointerId: 8 })
})
test('testing timestamp', () => {
const { getByTestId } = render(<Interactive gestures={['Drag']} />)
const element = getByTestId('drag-el')
let event = createEvent.pointerDown(element, { pointerId: 9, clientX: 10, clientY: 20, buttons: 1 })
fireEvent(element, event)
const start = event.timeStamp
expect(getByTestId('drag-timeStamp').innerHTML).toBe(String(start))
expect(getByTestId('drag-startTime').innerHTML).toBe(String(start))
expect(getByTestId('drag-elapsedTime').innerHTML).toBe('0')
event = createEvent.pointerMove(element, { pointerId: 9, clientX: 20, clientY: 50, buttons: 1 })
fireEvent(element, event)
let time = event.timeStamp
expect(getByTestId('drag-timeStamp').innerHTML).toBe(String(time))
expect(getByTestId('drag-startTime').innerHTML).toBe(String(start))
expect(getByTestId('drag-elapsedTime').innerHTML).toBe(String(time - start))
})
test('testing transform', () => {
const { getByTestId } = render(
<Interactive gestures={['Drag']} config={{ transform: ([x, y]) => [1 + x / 2, y / 4] }} />
)
const element = getByTestId('drag-el')
fireEvent.pointerDown(element, { pointerId: 10, clientX: 20, clientY: 40, buttons: 1 })
expect(getByTestId('drag-xy')).toHaveTextContent('11,10')
fireEvent.pointerMove(element, { pointerId: 10, clientX: 30, clientY: 80, buttons: 1 })
expect(getByTestId('drag-xy')).toHaveTextContent('16,20')
expect(getByTestId('drag-initial')).toHaveTextContent('11,10')
expect(getByTestId('drag-movement')).toHaveTextContent('5,10')
expect(getByTestId('drag-offset')).toHaveTextContent('5,10')
expect(getByTestId('drag-delta')).toHaveTextContent('5,10')
expect(getByTestId('drag-distance')).toHaveTextContent('5,10')
fireEvent.pointerUp(element, { pointerId: 10 })
})
test('testing unmount with domTarget', () => {
const { getByTestId, unmount } = render(<InteractiveDom gestures={['Drag']} />)
const element = getByTestId('dom-drag-el')
fireEvent.pointerDown(element, { pointerId: 11, buttons: 1 })
fireEvent.pointerMove(element, { pointerId: 11, clientX: 20, clientY: 50, buttons: 1 })
expect(getByTestId('dom-drag-dragging')).toHaveTextContent('true')
unmount()
})
|
7,234 | 0 | petrpan-code/pmndrs/use-gesture | petrpan-code/pmndrs/use-gesture/test/config.test.tsx | import { parse } from '../packages/core/src/config/resolver'
import { dragConfigResolver } from '../packages/core/src/config/dragConfigResolver'
import { pinchConfigResolver } from '../packages/core/src/config/pinchConfigResolver'
import { ConfigResolverMap } from '../packages/core/src/actions'
import { DragConfig, PinchConfig, CoordinatesConfig, Vector2, GenericOptions } from '../packages/core/src/types'
import { identity } from '../packages/core/src/config/commonConfigResolver'
import { wheelConfigResolver } from '../packages/core/src/config/wheelConfigResolver'
ConfigResolverMap.set('drag', dragConfigResolver)
ConfigResolverMap.set('pinch', pinchConfigResolver)
ConfigResolverMap.set('wheel', wheelConfigResolver)
describe('testing derived config', () => {
describe('testing derived generic configuration', () => {
test(`empty config should return default config`, () => {
expect(parse({}).shared).toStrictEqual({
enabled: true,
target: undefined,
transform: undefined,
eventOptions: { capture: false, passive: true },
window: window
})
})
test(`derived passive is false if target is specified and config passive is false`, () => {
const config = {
target: document.createElement('div'),
eventOptions: { passive: false }
}
expect(parse(config).shared).toHaveProperty('eventOptions.passive', false)
})
})
describe('testing internal gesture configuration', () => {
let config: CoordinatesConfig
test(`derived threshold array is set when threshold is a number`, () => {
config = { threshold: 10 }
expect(parse(config, 'wheel').wheel).toHaveProperty('threshold', [10, 10])
})
test(`derived rubberband should be set to array, and defaulted when set to true`, () => {
config = { rubberband: 0.3 }
expect(parse(config, 'wheel').wheel).toHaveProperty('rubberband', [0.3, 0.3])
config = { rubberband: true }
expect(parse(config, 'wheel').wheel).toHaveProperty('rubberband', [0.15, 0.15])
})
})
describe('testing drag configuration', () => {
test(`empty config should return default drag config`, () => {
expect(parse({}, 'drag').drag).toStrictEqual({
enabled: true,
eventOptions: { capture: false, passive: true },
device: 'pointer',
bounds: [
[-Infinity, Infinity],
[-Infinity, Infinity]
],
from: undefined,
transform: identity,
hasCustomTransform: false,
preventDefault: false,
keys: true,
triggerAllEvents: false,
delay: 0,
swipe: {
distance: [50, 50],
velocity: [0.5, 0.5],
duration: 250
},
threshold: [0, 0],
rubberband: [0, 0],
axis: undefined,
lockDirection: false,
preventScrollDelay: undefined,
preventScrollAxis: undefined,
pointerButtons: 1,
pointerLock: false,
pointerCapture: true,
filterTaps: false,
tapsThreshold: 3,
axisThreshold: { mouse: 0, pen: 8, touch: 0 },
keyboardDisplacement: 10
})
})
let dragConfig: DragConfig
test(`gesture eventOptions should override shared config`, () => {
let sharedConfig: GenericOptions = { eventOptions: { capture: true } }
dragConfig = { eventOptions: { passive: false } }
expect(parse({ ...sharedConfig, drag: dragConfig }).drag).toHaveProperty('eventOptions', {
passive: false,
capture: true
})
sharedConfig = {}
dragConfig = { eventOptions: { capture: true } }
expect(parse({ ...sharedConfig, drag: dragConfig }).drag).toHaveProperty('eventOptions', {
passive: true,
capture: true
})
})
test(`derived threshold is set when filterTaps, lockDirection or axis are not falsey`, () => {
dragConfig = { axis: 'lock' }
expect(parse(dragConfig, 'drag').drag).toHaveProperty('threshold', [1, 1])
expect(parse(dragConfig, 'drag').drag).toHaveProperty('axis', undefined)
dragConfig = { filterTaps: true, axis: 'lock' }
expect(parse(dragConfig, 'drag').drag).toHaveProperty('threshold', [3, 3])
dragConfig = { axis: 'y' }
expect(parse(dragConfig, 'drag').drag).toHaveProperty('threshold', [1, 1])
expect(parse(dragConfig, 'drag').drag).toHaveProperty('axis', 'y')
})
test(`derived delay is set to default when boolean`, () => {
dragConfig = { delay: true }
expect(parse(dragConfig, 'drag').drag).toHaveProperty('delay', 180)
dragConfig = { delay: false }
expect(parse(dragConfig, 'drag').drag).toHaveProperty('delay', 0)
})
test(`derived device is touch when pointer.touch is true`, () => {
dragConfig = { pointer: { touch: true } }
expect(parse(dragConfig, 'drag').drag).toHaveProperty('device', 'touch')
})
test(`derived device properly handles touch and lock`, () => {
dragConfig = { pointer: { touch: true, lock: true } }
expect(parse(dragConfig, 'drag').drag).toHaveProperty('device', 'touch')
/**
* @note unfortunately jsdom doesn't support pointer lock so device is
* `pointer` but it should be `mouse`.
*/
dragConfig.pointer!.touch = false
expect(parse(dragConfig, 'drag').drag).toHaveProperty('device', 'pointer')
})
test(`derived axisThreshold is preoperly computer`, () => {
const axisThreshold = { pen: 3, mouse: 2 }
dragConfig = { axisThreshold }
expect(parse(dragConfig, 'drag').drag).toHaveProperty('axisThreshold', { mouse: 2, pen: 3, touch: 0 })
})
test(`derived transform is properly computed`, () => {
const transform = ([x, y]: Vector2) => [x / 2, y / 4] as Vector2
dragConfig = { transform }
expect(parse(dragConfig, 'drag').drag).toHaveProperty('transform', transform)
expect(parse(dragConfig, 'drag').drag).toHaveProperty('hasCustomTransform', true)
})
test(`derived preventScrollDelay and preventScrollAxis are properly computed`, () => {
dragConfig = { preventScroll: true }
expect(parse(dragConfig, 'drag').drag).toHaveProperty('preventScrollDelay', 250)
expect(parse(dragConfig, 'drag').drag).toHaveProperty('preventScrollAxis', 'y')
dragConfig = { preventScroll: 300 }
expect(parse(dragConfig, 'drag').drag).toHaveProperty('preventScrollDelay', 300)
expect(parse(dragConfig, 'drag').drag).toHaveProperty('preventScrollAxis', 'y')
dragConfig = { preventScrollAxis: 'x' }
expect(parse(dragConfig, 'drag').drag).toHaveProperty('preventScrollDelay', 250)
expect(parse(dragConfig, 'drag').drag).toHaveProperty('preventScrollAxis', 'x')
dragConfig = { preventScrollAxis: 'x', preventScroll: false }
expect(parse(dragConfig, 'drag').drag).toHaveProperty('preventScrollDelay', undefined)
expect(parse(dragConfig, 'drag').drag).toHaveProperty('preventScrollAxis', undefined)
})
})
describe('testing distance / angle configuration', () => {
test(`empty config should return default distance / angle config`, () => {
expect(parse({}, 'pinch').pinch).toStrictEqual({
enabled: true,
eventOptions: { capture: false, passive: true },
bounds: [
[-Infinity, Infinity],
[-Infinity, Infinity]
],
device: 'pointer',
transform: identity,
hasCustomTransform: false,
triggerAllEvents: false,
preventDefault: false,
lockDirection: false,
from: undefined,
threshold: [0, 0],
rubberband: [0, 0],
modifierKey: 'ctrlKey',
pinchOnWheel: true
})
})
let config: PinchConfig
test(`derived bounds array matches [[distanceBounds], [angleBounds]]`, () => {
config = { scaleBounds: { min: 0.5, max: 1 }, angleBounds: { min: 0, max: 270 } }
expect(parse(config, 'pinch').pinch).toHaveProperty('bounds', [
[0.5, 1],
[0, 270]
])
})
test(`setting modifierKey to null should result in modifierKey being null`, () => {
config = { modifierKey: null }
expect(parse(config, 'pinch').pinch).toHaveProperty('modifierKey', null)
})
test(`setting modifierKey to array should result in modifierKey being an array`, () => {
config = { modifierKey: ['altKey', 'ctrlKey'] }
expect(parse(config, 'pinch').pinch).toHaveProperty('modifierKey', ['altKey', 'ctrlKey'])
})
})
})
|
7,235 | 0 | petrpan-code/pmndrs/use-gesture | petrpan-code/pmndrs/use-gesture/test/drag.test.tsx | import React from 'react'
import { render, cleanup, fireEvent, createEvent, waitFor } from '@testing-library/react'
import { later, patchCreateEvent } from './utils'
import '@testing-library/jest-dom/extend-expect'
import Interactive from './components/Interactive'
import InteractiveDom from './components/InteractiveDom'
import { InteractiveType } from './components/types'
afterAll(cleanup)
patchCreateEvent(createEvent)
describe.each([
['attached to component', Interactive, ''],
['attached to node', InteractiveDom, 'dom-']
])('testing onDrag %s', (_testName, C, prefix): any => {
const Component = C as InteractiveType
const { getByTestId, rerender } = render(<Component bindArgs={[2]} gestures={['Drag']} memoArg="memo" />)
const element = getByTestId(`${prefix}drag-el`)
let delta_t: number
let lastVelocity: string
test('pointerDown should initiate the gesture', () => {
const event = createEvent.pointerDown(element, { pointerId: 1, clientX: 10, clientY: 20, buttons: 1 })
fireEvent(element, event)
delta_t = event.timeStamp
expect(getByTestId(`${prefix}drag-active`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}drag-dragging`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}drag-first`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}drag-xy`)).toHaveTextContent('10,20')
expect(getByTestId(`${prefix}drag-offset`)).toHaveTextContent('0,0')
expect(getByTestId(`${prefix}drag-delta`)).toHaveTextContent('0,0')
expect(getByTestId(`${prefix}drag-down`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}drag-initial`)).toHaveTextContent('10,20')
})
test('initiating the gesture should fire onDragStart', () => {
expect(getByTestId(`${prefix}drag-start`)).toHaveTextContent(/^fired$/)
expect(getByTestId(`${prefix}drag-end`)).toHaveTextContent(/^not fired$/)
})
test('testing memo value is passed', () => {
expect(getByTestId(`${prefix}drag-memo`)).toHaveTextContent('memo')
})
test('moving should set first to false', () => {
const event = createEvent.pointerMove(element, { pointerId: 1, clientX: 20, clientY: 50, buttons: 1 })
fireEvent(element, event)
delta_t = event.timeStamp - delta_t
expect(getByTestId(`${prefix}drag-first`)).toHaveTextContent('false')
})
test('moving should update kinematics', () => {
expect(getByTestId(`${prefix}drag-xy`)).toHaveTextContent('20,50')
expect(getByTestId(`${prefix}drag-offset`)).toHaveTextContent('10,30')
expect(getByTestId(`${prefix}drag-movement`)).toHaveTextContent('10,30')
expect(getByTestId(`${prefix}drag-delta`)).toHaveTextContent('10,30')
expect(getByTestId(`${prefix}drag-velocity`)).toHaveTextContent(`${10 / delta_t},${30 / delta_t}`)
})
test('moving again should further update xy and movement', () => {
fireEvent.pointerMove(element, { pointerId: 1, clientX: -10, clientY: 30, buttons: 1 })
expect(getByTestId(`${prefix}drag-xy`)).toHaveTextContent('-10,30')
expect(getByTestId(`${prefix}drag-offset`)).toHaveTextContent('-20,10')
expect(getByTestId(`${prefix}drag-movement`)).toHaveTextContent('-20,10')
expect(getByTestId(`${prefix}drag-delta`)).toHaveTextContent('-30,-20')
})
test(`adding another pointer to the element shouldn't disturb the drag`, () => {
fireEvent.pointerDown(element, { pointerId: 111, buttons: 1 })
fireEvent.pointerMove(element, { pointerId: 111, clientX: -10, clientY: 30, buttons: 1 })
fireEvent.pointerUp(element, { pointerId: 111 })
expect(getByTestId(`${prefix}drag-active`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}drag-offset`)).toHaveTextContent('-20,10')
expect(getByTestId(`${prefix}drag-movement`)).toHaveTextContent('-20,10')
})
test('pointerUp should terminate the gesture', () => {
lastVelocity = getByTestId(`${prefix}drag-velocity`).textContent
fireEvent.pointerUp(element, { pointerId: 1 })
expect(getByTestId(`${prefix}drag-dragging`)).toHaveTextContent('false')
expect(getByTestId(`${prefix}drag-active`)).toHaveTextContent('false')
expect(getByTestId(`${prefix}drag-last`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}drag-intentional`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}drag-down`)).toHaveTextContent('false')
})
test(`pointerUp released in less than 32ms shouldn't change kinematics`, () => {
expect(getByTestId(`${prefix}drag-velocity`)).toHaveTextContent(lastVelocity)
})
test('terminating the gesture should fire onDragEnd', () => {
expect(getByTestId(`${prefix}drag-end`)).toHaveTextContent(/^fired$/)
})
test('disabling all gestures should prevent state from updating', () => {
rerender(<Component gestures={['Drag']} config={{ enabled: false }} />)
fireEvent.pointerDown(element, { pointerId: 2, buttons: 1 })
expect(getByTestId(`${prefix}drag-dragging`)).toHaveTextContent('false')
fireEvent.pointerUp(element, { pointerId: 2 })
})
test('disabling the drag gesture should prevent state from updating', () => {
rerender(<Component gestures={['Drag']} config={{ drag: { enabled: false } }} />)
fireEvent.pointerDown(element, { pointerId: 3, buttons: 1 })
expect(getByTestId(`${prefix}drag-dragging`)).toHaveTextContent('false')
fireEvent.pointerUp(element, { pointerId: 3 })
})
test('restarting the gesture should book-keep offset and reset movement', () => {
rerender(<Component gestures={['Drag']} />)
fireEvent.pointerDown(element, { pointerId: 4, clientX: 30, clientY: 60, buttons: 1 })
fireEvent.pointerMove(element, { pointerId: 4, clientX: 20, clientY: 50, buttons: 1 })
expect(getByTestId(`${prefix}drag-offset`)).toHaveTextContent('-30,0')
expect(getByTestId(`${prefix}drag-movement`)).toHaveTextContent('-10,-10')
})
test('releasing pointer after more than 32ms should reset kinematics', async () => {
const lastTimeStamp = Number(getByTestId(`${prefix}drag-timeStamp`).textContent)
await later(50)
fireEvent.pointerUp(element, { pointerId: 4 })
const latestTimeStamp = Number(getByTestId(`${prefix}drag-timeStamp`).textContent)
expect(latestTimeStamp - lastTimeStamp).toBeGreaterThan(32)
expect(getByTestId(`${prefix}drag-velocity`)).toHaveTextContent('0,0')
expect(getByTestId(`${prefix}drag-delta`)).toHaveTextContent('0,0')
expect(getByTestId(`${prefix}drag-direction`)).toHaveTextContent('0,0')
})
test('canceling the gesture should cancel the gesture in the next RAF tick', async () => {
rerender(<Component gestures={['Drag']} canceled />)
fireEvent.pointerDown(element, { pointerId: 5, clientX: 30, clientY: 60, buttons: 1 })
await waitFor(() => [
expect(getByTestId(`${prefix}drag-canceled`)).toHaveTextContent('true'),
expect(getByTestId(`${prefix}drag-dragging`)).toHaveTextContent('false')
])
})
test('applying a dragDelay should start the gesture after a delay', async () => {
rerender(<Component gestures={['Drag']} config={{ drag: { delay: 180 } }} />)
fireEvent.pointerDown(element, { pointerId: 6, clientX: 100, clientY: 200, buttons: 1 })
expect(getByTestId(`${prefix}drag-dragging`)).toHaveTextContent('false')
await waitFor(() => [
expect(getByTestId(`${prefix}drag-dragging`)).toHaveTextContent('true'),
expect(getByTestId(`${prefix}drag-xy`)).toHaveTextContent('100,200')
])
fireEvent.pointerUp(element, { pointerId: 6 })
})
test('moving the pointer with a dragDelay should start the gesture without waiting', () => {
fireEvent.pointerDown(element, { pointerId: 7, clientX: 100, clientY: 200, buttons: 1 })
fireEvent.pointerMove(element, { pointerId: 7, clientX: 20, clientY: 50, buttons: 1 })
expect(getByTestId(`${prefix}drag-dragging`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}drag-xy`)).toHaveTextContent('20,50')
expect(getByTestId(`${prefix}drag-offset`)).toHaveTextContent('-110,-150')
fireEvent.pointerUp(element, { pointerId: 7 })
})
test(`quickly tapping shouldn't trigger a drag`, async () => {
fireEvent.click(element, { clientX: 100, clientY: 200 })
await waitFor(() => expect(getByTestId(`${prefix}drag-dragging`)).toHaveTextContent('false'), { timeout: 200 })
})
test(`applying a threshold should prevent the gesture from starting if it's NOT reached`, () => {
rerender(<Component gestures={['Drag']} config={{ drag: { threshold: 10 } }} />)
fireEvent.pointerDown(element, { pointerId: 8, clientX: 0, clientY: 0, buttons: 1 })
fireEvent.pointerMove(element, { pointerId: 8, clientX: 5, clientY: 5, buttons: 1 })
expect(getByTestId(`${prefix}drag-dragging`)).toHaveTextContent('false')
})
test(`applying a threshold should allow the gesture to start when it's reached`, async () => {
await later()
fireEvent.pointerMove(element, { pointerId: 8, clientX: 12, clientY: 12, buttons: 1 })
expect(getByTestId(`${prefix}drag-dragging`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}drag-movement`)).toHaveTextContent('2,2')
expect(getByTestId(`${prefix}drag-offset`)).toHaveTextContent('-108,-148')
fireEvent.pointerUp(element, { pointerId: 8 })
})
test(`applying an axis SHOULDN'T start the gesture if gesture is not detected first in the right axis`, async () => {
rerender(<Component gestures={['Drag']} config={{ drag: { axis: 'x' } }} />)
fireEvent.pointerDown(element, { pointerId: 81, clientX: 0, clientY: 0, buttons: 1 })
fireEvent.pointerMove(element, { pointerId: 81, clientX: 0, clientY: 50, buttons: 1 })
await later()
fireEvent.pointerMove(element, { pointerId: 81, clientX: 10, clientY: 0, buttons: 1 })
expect(getByTestId(`${prefix}drag-dragging`)).toHaveTextContent('false')
fireEvent.pointerUp(element, { pointerId: 81 })
})
test(`applying an axis SHOULD start the gesture if gesture is detected in the right axis`, () => {
rerender(<Component gestures={['Drag']} config={{ drag: { axis: 'x' } }} />)
fireEvent.pointerDown(element, { pointerId: 9, clientX: 0, clientY: 0, buttons: 1 })
fireEvent.pointerMove(element, { pointerId: 9, clientX: 20, clientY: 10, buttons: 1 })
expect(getByTestId(`${prefix}drag-dragging`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}drag-movement`)).toHaveTextContent('19,0')
fireEvent.pointerUp(element, { pointerId: 9 })
})
test(`applying a direction lock SHOULD only update the first detected direction`, () => {
rerender(<Component gestures={['Drag']} config={{ drag: { axis: 'lock' } }} />)
fireEvent.pointerDown(element, { pointerId: 10, clientX: 0, clientY: 0, buttons: 1 })
fireEvent.pointerMove(element, { pointerId: 10, clientX: 5, clientY: 15, buttons: 1 })
fireEvent.pointerMove(element, { pointerId: 10, clientX: 50, clientY: 30, buttons: 1 })
expect(getByTestId(`${prefix}drag-dragging`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}drag-movement`)).toHaveTextContent('0,29')
fireEvent.pointerUp(element, { pointerId: 10 })
expect(getByTestId(`${prefix}drag-dragging`)).toHaveTextContent('false')
fireEvent.pointerDown(element, { pointerId: 11, clientX: 0, clientY: 0, buttons: 1 })
fireEvent.pointerMove(element, { pointerId: 11, clientX: 20, clientY: 10, buttons: 1 })
fireEvent.pointerMove(element, { pointerId: 11, clientX: 35, clientY: 40, buttons: 1 })
expect(getByTestId(`${prefix}drag-dragging`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}drag-movement`)).toHaveTextContent('34,0')
expect(getByTestId(`${prefix}drag-offset`)).toHaveTextContent('-55,-119')
fireEvent.pointerUp(element, { pointerId: 11 })
})
test(`filtering taps should NOT fire a tap if pointer has moved more than 3px`, () => {
expect(getByTestId(`${prefix}drag-tap`)).toHaveTextContent('false')
expect(getByTestId(`${prefix}drag-dragging`)).toHaveTextContent('false')
rerender(<Component gestures={['Drag']} config={{ drag: { filterTaps: true, threshold: 10 } }} />)
fireEvent.pointerDown(element, { pointerId: 12, clientX: 0, clientY: 0, buttons: 1 })
fireEvent.pointerMove(element, { pointerId: 12, clientX: 8, clientY: 1, buttons: 1 })
expect(getByTestId(`${prefix}drag-dragging`)).toHaveTextContent('false')
fireEvent.pointerUp(element, { pointerId: 12 })
expect(getByTestId(`${prefix}drag-dragging`)).toHaveTextContent('false')
expect(getByTestId(`${prefix}drag-tap`)).toHaveTextContent('false')
})
// TODO add a test to verify underlying children's onClick handler is not triggered
// when filterTaps is true
test(`filtering taps should fire a tap if pointer has moved less than 3px`, async () => {
let event = createEvent.pointerDown(element, { pointerId: 13, clientX: 0, clientY: 0, buttons: 1 })
fireEvent(element, event)
delta_t = event.timeStamp
fireEvent.pointerMove(element, { pointerId: 13, clientX: 2, clientY: 1, buttons: 1 })
expect(getByTestId(`${prefix}drag-dragging`)).toHaveTextContent('false')
expect(getByTestId(`${prefix}drag-tap`)).toHaveTextContent('false')
event = createEvent.pointerUp(element, { pointerId: 13 })
delta_t = event.timeStamp - delta_t
fireEvent(element, event)
await waitFor(
() => {
expect(getByTestId(`${prefix}drag-tap`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}drag-elapsedTime`)).toHaveTextContent(String(delta_t))
expect(getByTestId(`${prefix}drag-dragging`)).toHaveTextContent('false')
},
{ timeout: 200 }
)
})
test(`triggerAllEvents should trigger all events even if gesture is unintentional`, () => {
rerender(<Component gestures={['Drag']} config={{ drag: { threshold: 10, triggerAllEvents: true } }} />)
fireEvent.pointerDown(element, { pointerId: 14, clientX: 0, clientY: 0, buttons: 1 })
fireEvent.pointerMove(element, { pointerId: 14, clientX: 8, clientY: 1, buttons: 1 })
expect(getByTestId(`${prefix}drag-dragging`)).toHaveTextContent('false')
expect(getByTestId(`${prefix}drag-intentional`)).toHaveTextContent('false')
fireEvent.pointerMove(element, { pointerId: 14, clientX: 14, clientY: 1, buttons: 1 })
expect(getByTestId(`${prefix}drag-intentional`)).toHaveTextContent('true')
fireEvent.pointerUp(element, { pointerId: 14 })
expect(getByTestId(`${prefix}drag-intentional`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}drag-dragging`)).toHaveTextContent('false')
})
test(`bounds should limit both offset and movement`, () => {
rerender(
<Component
gestures={['Drag']}
config={{ drag: { bounds: { top: -100, bottom: 200, left: -150, right: 250 } } }}
/>
)
expect(getByTestId(`${prefix}drag-offset`)).toHaveTextContent('-51,-119')
fireEvent.pointerDown(element, { pointerId: 15, clientX: 200, clientY: 300, buttons: 1 })
fireEvent.pointerMove(element, { pointerId: 15, clientX: 10, clientY: 150, buttons: 1 })
expect(getByTestId(`${prefix}drag-movement`)).toHaveTextContent('-99,19')
expect(getByTestId(`${prefix}drag-offset`)).toHaveTextContent('-150,-100')
fireEvent.pointerUp(element, { pointerId: 15 })
fireEvent.pointerDown(element, { pointerId: 16, clientX: 100, clientY: 100, buttons: 1 })
fireEvent.pointerMove(element, { pointerId: 16, clientX: 40, clientY: 160, buttons: 1 })
expect(getByTestId(`${prefix}drag-movement`)).toHaveTextContent('0,60')
expect(getByTestId(`${prefix}drag-offset`)).toHaveTextContent('-150,-40')
fireEvent.pointerUp(element, { pointerId: 16 })
})
test(`rubberbanding should apply rubberband main function with set min and max`, () => {
rerender(
<Component gestures={['Drag']} config={{ drag: { bounds: { top: -100, bottom: 200 }, rubberband: true } }} />
)
fireEvent.pointerDown(element, { pointerId: 17, clientX: 200, clientY: 300, buttons: 1 })
fireEvent.pointerMove(element, { pointerId: 17, clientX: 200, clientY: 550, buttons: 1 })
const delta = 550 - 300 - 40
const dimension = 200 - -100
const rubberband = ((delta - 200) * dimension * 0.15) / (dimension + 0.15 * (delta - 200)) + 200
expect(getByTestId(`${prefix}drag-offset`)).toHaveTextContent(`-150,${rubberband}`)
})
test(`releasing drag with rubberbanding should revert movement to its closest bound`, () => {
fireEvent.pointerUp(element, { pointerId: 17 })
expect(getByTestId(`${prefix}drag-offset`)).toHaveTextContent(`-150,200`)
})
test(`rubberbanding should apply rubberband secondary function when only one bound is set`, () => {
rerender(<Component gestures={['Drag']} config={{ drag: { bounds: { bottom: 200 }, rubberband: true } }} />)
fireEvent.pointerDown(element, { pointerId: 18, clientX: 200, clientY: 300, buttons: 1 })
fireEvent.pointerMove(element, { pointerId: 18, clientX: 200, clientY: 550, buttons: 1 })
const delta = 550 - 300 + 200
const rubberband = Math.pow(delta - 200, 0.15 * 5) + 200
expect(getByTestId(`${prefix}drag-offset`)).toHaveTextContent(`-150,${rubberband}`)
fireEvent.pointerUp(element, { pointerId: 18 })
})
// this test uses bindArgs which are only accessible when attaching handlers to the component
// (ie without the domTarget option)
if (_testName === 'attached to component') {
test(`bounds function should define _bounds in state`, () => {
// fireEvent.pointerUp(element)
rerender(
<Component
gestures={['Drag']}
bindArgs={[2]}
config={{
drag: {
bounds: ({ args: [i] }) => ({ top: i * 100, left: i * -200 })
}
}}
/>
)
fireEvent.pointerDown(element, { pointerId: 19, clientX: 0, clientY: 0, buttons: 1 })
expect(getByTestId(`${prefix}drag-_bounds`)).toHaveTextContent('-400,Infinity,200,Infinity')
fireEvent.pointerUp(element, { pointerId: 19 })
})
}
test(`passing an initial position should affect the movement`, () => {
rerender(<Component gestures={['Drag']} config={{ drag: { from: () => [5, 10] } }} />)
fireEvent.pointerDown(element, { pointerId: 20, clientX: 0, clientY: 0, buttons: 1 })
expect(getByTestId(`${prefix}drag-offset`)).toHaveTextContent(`5,10`)
expect(getByTestId(`${prefix}drag-movement`)).toHaveTextContent(`0,0`)
fireEvent.pointerMove(element, { pointerId: 20, clientX: 10, clientY: 20, buttons: 1 })
expect(getByTestId(`${prefix}drag-offset`)).toHaveTextContent(`15,30`)
expect(getByTestId(`${prefix}drag-movement`)).toHaveTextContent(`10,20`)
fireEvent.pointerUp(element, { pointerId: 20 })
})
test(`drag should start only when it matches pointer.buttons config`, () => {
rerender(<Component gestures={['Drag']} />)
fireEvent.pointerDown(element, { pointerId: 21, buttons: 2 })
expect(getByTestId(`${prefix}drag-active`)).toHaveTextContent(`false`)
fireEvent.pointerUp(element, { pointerId: 21 })
rerender(<Component gestures={['Drag']} config={{ drag: { pointer: { buttons: 2 } } }} />)
fireEvent.pointerDown(element, { pointerId: 22, buttons: 2 })
expect(getByTestId(`${prefix}drag-active`)).toHaveTextContent(`true`)
fireEvent.pointerUp(element, { pointerId: 22 })
expect(getByTestId(`${prefix}drag-active`)).toHaveTextContent(`false`)
})
test(`drag should start no matter what when pointer.buttons is equal to -1`, () => {
// -1 triggers drag for any buttons config
rerender(<Component gestures={['Drag']} config={{ drag: { pointer: { buttons: -1 } } }} />)
fireEvent.pointerDown(element, { pointerId: 23, buttons: 16 })
expect(getByTestId(`${prefix}drag-active`)).toHaveTextContent(`true`)
fireEvent.pointerUp(element, { pointerId: 23 })
expect(getByTestId(`${prefix}drag-active`)).toHaveTextContent(`false`)
})
test(`drag should start when pointer.buttons is included inside pointer.buttons`, () => {
rerender(<Component gestures={['Drag']} config={{ drag: { pointer: { buttons: [1, 2, 4] } } }} />)
fireEvent.pointerDown(element, { pointerId: 24, buttons: 2 })
expect(getByTestId(`${prefix}drag-active`)).toHaveTextContent(`true`)
fireEvent.pointerUp(element, { pointerId: 24 })
expect(getByTestId(`${prefix}drag-active`)).toHaveTextContent(`false`)
fireEvent.pointerDown(element, { pointerId: 25, buttons: 4 })
expect(getByTestId(`${prefix}drag-active`)).toHaveTextContent(`true`)
fireEvent.pointerUp(element, { pointerId: 25 })
})
test(`drag should not start when pointer.buttons is not included inside pointer.buttons`, () => {
rerender(<Component gestures={['Drag']} config={{ drag: { pointer: { buttons: [1, 2, 4] } } }} />)
fireEvent.pointerDown(element, { pointerId: 26, buttons: 16 })
expect(getByTestId(`${prefix}drag-active`)).toHaveTextContent(`false`)
fireEvent.pointerUp(element, { pointerId: 26 })
})
test(`drag should react to key press`, () => {
rerender(<Component gestures={['Drag']} />)
fireEvent.keyDown(element, { key: 'ArrowDown' })
expect(getByTestId(`${prefix}drag-active`)).toHaveTextContent(`true`)
expect(getByTestId(`${prefix}drag-offset`)).toHaveTextContent(`15,40`)
fireEvent.keyDown(element, { key: 'ArrowLeft', shiftKey: true })
expect(getByTestId(`${prefix}drag-offset`)).toHaveTextContent(`-85,40`)
rerender(<Component gestures={['Drag']} config={{ drag: { keyboardDisplacement: 25 } }} />)
fireEvent.keyDown(element, { key: 'ArrowUp' })
expect(getByTestId(`${prefix}drag-offset`)).toHaveTextContent(`-85,15`)
fireEvent.keyDown(element, { key: 'ArrowLeft', altKey: true })
expect(getByTestId(`${prefix}drag-offset`)).toHaveTextContent(`-87.5,15`)
fireEvent.keyUp(element, { key: 'ArrowDown' })
expect(getByTestId(`${prefix}drag-active`)).toHaveTextContent(`false`)
})
test(`drag should not react to key press when pointer.key = false`, () => {
rerender(<Component gestures={['Drag']} config={{ drag: { pointer: { keys: false } } }} />)
fireEvent.keyDown(element, { key: 'ArrowDown' })
expect(getByTestId(`${prefix}drag-active`)).toHaveTextContent(`false`)
})
})
|
7,237 | 0 | petrpan-code/pmndrs/use-gesture | petrpan-code/pmndrs/use-gesture/test/hover.test.tsx | import React from 'react'
import { render, cleanup, fireEvent, createEvent } from '@testing-library/react'
import '@testing-library/jest-dom/extend-expect'
import Interactive from './components/Interactive'
import { InteractiveType } from './components/types'
import { patchCreateEvent } from './utils'
import InteractiveDom from './components/InteractiveDom'
afterAll(cleanup)
patchCreateEvent(createEvent)
// TODO - should be able to test on a node component
// but for some reason, the tests don't work with pointerEnter/mouseLeave
describe.each([
['attached to component', Interactive, false],
['attached to node', InteractiveDom, true]
])('testing onHover %s)', (_testName, C, domTarget) => {
const Component = C as InteractiveType
const prefix = domTarget ? 'dom-' : ''
const { getByTestId, rerender } = render(<Component gestures={['Hover']} />)
const element = getByTestId(`${prefix}hover-el`)
test('pointerEnter should initiate hover', () => {
fireEvent.pointerEnter(element, { clientX: 10, clientY: 20 })
expect(getByTestId(`${prefix}hover-hovering`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}hover-xy`)).toHaveTextContent('10,20')
})
test('pointerLeave should terminate hover', () => {
fireEvent.pointerLeave(element, { clientX: 20, clientY: 40 })
expect(getByTestId(`${prefix}hover-hovering`)).toHaveTextContent('false')
expect(getByTestId(`${prefix}hover-xy`)).toHaveTextContent('20,40')
})
test(`pointerType touch shouldn't trigger hover by default`, () => {
fireEvent.pointerEnter(element, { pointerType: 'touch' })
expect(getByTestId(`${prefix}hover-hovering`)).toHaveTextContent('false')
})
test(`pointerType touch should trigger hover with mouseOnly false`, () => {
rerender(<Component gestures={['Hover']} config={{ hover: { mouseOnly: false } }} />)
fireEvent.pointerEnter(element, { pointerType: 'touch' })
expect(getByTestId(`${prefix}hover-hovering`)).toHaveTextContent('true')
fireEvent.pointerLeave(element, { pointerType: 'touch' })
expect(getByTestId(`${prefix}hover-hovering`)).toHaveTextContent('false')
})
test('disabling all gestures should prevent state from updating', () => {
rerender(<Component gestures={['Hover']} config={{ enabled: false }} />)
fireEvent.pointerEnter(element)
expect(getByTestId(`${prefix}hover-hovering`)).toHaveTextContent('false')
})
test('disabling the hover gesture should prevent state from updating', () => {
rerender(<Component gestures={['Hover']} config={{ hover: { enabled: false } }} />)
fireEvent.pointerEnter(element)
expect(getByTestId(`${prefix}hover-hovering`)).toHaveTextContent('false')
})
})
|
7,238 | 0 | petrpan-code/pmndrs/use-gesture | petrpan-code/pmndrs/use-gesture/test/move.test.tsx | import React from 'react'
import { render, cleanup, fireEvent, createEvent, waitFor } from '@testing-library/react'
import '@testing-library/jest-dom/extend-expect'
import { later, patchCreateEvent } from './utils'
import Interactive from './components/Interactive'
import InteractiveDom from './components/InteractiveDom'
import { InteractiveType } from './components/types'
afterAll(cleanup)
patchCreateEvent(createEvent)
describe.each([
['attached to component', Interactive, ''],
['attached to node', InteractiveDom, 'dom-']
])('testing onMove %s)', (_testName, C, prefix) => {
const Component = C as InteractiveType
const { getByTestId, rerender } = render(<Component gestures={['Move']} memoArg="memo" />)
const element = getByTestId(`${prefix}move-el`)
let delta_t: number
test('pointerMove should initiate the gesture', () => {
const event = createEvent.pointerMove(element, { clientX: 20, clientY: 50 })
fireEvent(element, event)
delta_t = event.timeStamp
expect(getByTestId(`${prefix}move-active`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}move-moving`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}move-first`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}move-xy`)).toHaveTextContent('20,50')
expect(getByTestId(`${prefix}move-delta`)).toHaveTextContent('0,0')
expect(getByTestId(`${prefix}move-initial`)).toHaveTextContent('20,50')
})
test('initiating the gesture should fire onMoveStart', () => {
expect(getByTestId(`${prefix}move-start`)).toHaveTextContent(/^fired$/)
expect(getByTestId(`${prefix}move-end`)).toHaveTextContent(/^not fired$/)
})
test('testing memo value is passed', () => {
expect(getByTestId(`${prefix}move-memo`)).toHaveTextContent('memo')
})
test('the second pointerMove event should set first to false', () => {
const event = createEvent.pointerMove(element, { clientX: 30, clientY: 80 })
fireEvent(element, event)
delta_t = event.timeStamp - delta_t
expect(getByTestId(`${prefix}move-first`)).toHaveTextContent('false')
expect(getByTestId(`${prefix}move-last`)).toHaveTextContent('false')
})
test('xy should update to latest mouse coordinates', () => {
expect(getByTestId(`${prefix}move-xy`)).toHaveTextContent('30,80')
expect(getByTestId(`${prefix}move-movement`)).toHaveTextContent('10,30')
})
test('kinematics should update', () => {
expect(getByTestId(`${prefix}move-velocity`)).toHaveTextContent(`${10 / delta_t},${30 / delta_t}`)
})
test('the last pointerMove event should debounce and terminate the gesture', async () => {
await waitFor(() => {
expect(getByTestId(`${prefix}move-last`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}move-active`)).toHaveTextContent('false')
expect(getByTestId(`${prefix}move-velocity`)).toHaveTextContent(`${10 / delta_t},${30 / delta_t}`)
expect(getByTestId(`${prefix}move-moving`)).toHaveTextContent('false')
})
})
test('terminating the gesture should fire onMoveEnd', async () => {
await waitFor(() => expect(getByTestId(`${prefix}move-end`)).toHaveTextContent(/^fired$/))
})
test(`applying an axis SHOULDN'T start the gesture if gesture is not detected first in the right axis`, async () => {
rerender(<Component gestures={['Move']} config={{ move: { axis: 'x' } }} />)
fireEvent.pointerMove(element, { clientX: 0, clientY: 0 })
fireEvent.pointerMove(element, { clientX: 0, clientY: 10 })
fireEvent.pointerMove(element, { clientX: 4, clientY: 10 })
expect(getByTestId(`${prefix}move-moving`)).toHaveTextContent('false')
// allow gesture to finish
await later(200)
})
test(`applying an axis SHOULD start the gesture if gesture is detected in the right axis`, async () => {
fireEvent.pointerMove(element, { clientX: 0, clientY: 0 })
fireEvent.pointerMove(element, { clientX: 10, clientY: 4 })
fireEvent.pointerMove(element, { clientX: 13, clientY: 4 })
expect(getByTestId(`${prefix}move-moving`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}move-movement`)).toHaveTextContent('13,0')
await waitFor(() => expect(getByTestId(`${prefix}move-moving`)).toHaveTextContent('false'))
})
test(`pointerType touch shouldn't trigger move by default`, () => {
fireEvent.pointerMove(element, { pointerType: 'touch' })
expect(getByTestId(`${prefix}move-moving`)).toHaveTextContent('false')
})
test(`pointerType touch should trigger move with mouseOnly false`, async () => {
rerender(<Component gestures={['Move']} config={{ move: { mouseOnly: false } }} />)
fireEvent.pointerMove(element, { pointerType: 'touch' })
expect(getByTestId(`${prefix}move-moving`)).toHaveTextContent('true')
await waitFor(() => expect(getByTestId(`${prefix}move-moving`)).toHaveTextContent('false'))
})
test('disabling all gestures should prevent state from updating', () => {
rerender(<Component gestures={['Move']} config={{ enabled: false }} />)
fireEvent.pointerMove(element)
expect(getByTestId(`${prefix}move-moving`)).toHaveTextContent('false')
})
test('disabling the move gesture should prevent state from updating', () => {
rerender(<Component gestures={['Move']} config={{ move: { enabled: false } }} />)
fireEvent.pointerMove(element)
expect(getByTestId(`${prefix}move-moving`)).toHaveTextContent('false')
})
})
|
7,239 | 0 | petrpan-code/pmndrs/use-gesture | petrpan-code/pmndrs/use-gesture/test/pinch.test.tsx | import React from 'react'
import { render, cleanup, fireEvent, createEvent, waitFor } from '@testing-library/react'
import '@testing-library/jest-dom/extend-expect'
import Interactive from './components/Interactive'
import InteractiveDom from './components/InteractiveDom'
import { InteractiveType } from './components/types'
import { patchCreateEvent } from './utils'
afterAll(cleanup)
patchCreateEvent(createEvent)
// TODO test with gesturechange and touch
describe.each([
['attached to component', Interactive, ''],
['attached to node', InteractiveDom, 'dom-']
])('testing onPinch %s)', (_testName, C, prefix) => {
const Component = C as InteractiveType
const { getByTestId, queryByTestId, rerender } = render(<Component gestures={['Pinch']} memoArg="memo" />)
const element = getByTestId(`${prefix}pinch-el`)
let delta_t: number
let offset: number
test('one-finger touch should NOT initiate the gesture', () => {
fireEvent.pointerDown(element, { pointerId: 1, clientX: 10, clientY: 20, buttons: 1 })
expect(queryByTestId(`${prefix}pinch-active`)).not.toBeInTheDocument()
})
test('one-finger touch release should NOT trigger on end', () => {
fireEvent.pointerUp(element, { pointerId: 1 })
expect(getByTestId(`${prefix}pinch-end`)).toHaveTextContent(/^not fired$/)
})
test('touch with two fingers should initiate the gesture', () => {
fireEvent.pointerDown(element, { pointerId: 21, clientX: 0, clientY: 0, buttons: 1 })
expect(queryByTestId(`${prefix}pinch-active`)).not.toBeInTheDocument()
const event = createEvent.pointerDown(element, { pointerId: 22, clientX: 0, clientY: 40, buttons: 1 })
fireEvent(element, event)
delta_t = event.timeStamp
expect(getByTestId(`${prefix}pinch-active`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}pinch-pinching`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}pinch-first`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}pinch-da`)).toHaveTextContent(`40,0`)
expect(getByTestId(`${prefix}pinch-delta`)).toHaveTextContent('0,0')
expect(getByTestId(`${prefix}pinch-origin`)).toHaveTextContent(`0,20`)
expect(getByTestId(`${prefix}pinch-initial`)).toHaveTextContent(`40,0`)
expect(getByTestId(`${prefix}pinch-offset`)).toHaveTextContent(`1,0`)
expect(getByTestId(`${prefix}pinch-movement`)).toHaveTextContent(`1,0`)
expect(getByTestId(`${prefix}pinch-touches`)).toHaveTextContent('2')
})
test('initiating the gesture should fire onPinchStart', () => {
expect(getByTestId(`${prefix}pinch-start`)).toHaveTextContent(/^fired$/)
expect(getByTestId(`${prefix}pinch-end`)).toHaveTextContent(/^not fired$/)
})
test('testing memo value is passed', () => {
expect(getByTestId(`${prefix}pinch-memo`)).toHaveTextContent('memo')
})
test('moving should set first to false', () => {
const event = createEvent.pointerMove(element, { pointerId: 22, clientX: 30, clientY: 0, buttons: 1 })
fireEvent(element, event)
delta_t = event.timeStamp - delta_t
expect(getByTestId(`${prefix}pinch-first`)).toHaveTextContent('false')
})
test('moving should update distance/angle and movement', () => {
const delta = (30 - 40) / 40
offset = 1 + delta
expect(getByTestId(`${prefix}pinch-da`)).toHaveTextContent(`30,-90`)
expect(getByTestId(`${prefix}pinch-movement`)).toHaveTextContent(`${1 + delta},-90`)
expect(getByTestId(`${prefix}pinch-offset`)).toHaveTextContent(`${offset},-90`)
expect(getByTestId(`${prefix}pinch-delta`)).toHaveTextContent(`${delta},-90`)
expect(getByTestId(`${prefix}pinch-origin`)).toHaveTextContent(`15,0`)
expect(getByTestId(`${prefix}pinch-direction`)).toHaveTextContent(`-1,-1`)
})
test('moving should update kinematics', () => {
const delta = (30 - 40) / 40
expect(getByTestId(`${prefix}pinch-velocity`)).toHaveTextContent(`${Math.abs(delta) / delta_t},${90 / delta_t}`)
})
// TODO potentially having three fingers on target and only ONE lifted up would trigger pinchEnd
test('releasing ONE finger should terminate the gesture', () => {
fireEvent.pointerUp(element, { pointerId: 21 })
expect(getByTestId(`${prefix}pinch-pinching`)).toHaveTextContent('false')
expect(getByTestId(`${prefix}pinch-active`)).toHaveTextContent('false')
expect(getByTestId(`${prefix}pinch-last`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}pinch-down`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}pinch-touches`)).toHaveTextContent('1')
})
test('terminating the gesture should fire onPinchEnd', () => {
expect(getByTestId(`${prefix}pinch-end`)).toHaveTextContent(/^fired$/)
fireEvent.pointerUp(element, { pointerId: 22 })
})
test('restarting the gesture should book-keep offset and reset movement', () => {
fireEvent.pointerDown(element, { pointerId: 31, clientX: 0, clientY: 0, buttons: 1 })
fireEvent.pointerDown(element, { pointerId: 32, clientX: 0, clientY: 40, buttons: 1 })
fireEvent.pointerMove(element, { pointerId: 32, clientX: -30, clientY: 0, buttons: 1 })
const delta = (30 - 40) / 40
offset *= 1 + delta
expect(getByTestId(`${prefix}pinch-da`)).toHaveTextContent(`30,90`)
expect(getByTestId(`${prefix}pinch-active`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}pinch-movement`)).toHaveTextContent(`${1 + delta},90`)
expect(getByTestId(`${prefix}pinch-offset`)).toHaveTextContent(`${offset},0`)
})
test('using wheel with ctrl key pressed should update pinch distance/angle', () => {
fireEvent.wheel(element, { deltaX: 4, deltaY: -5, ctrlKey: true })
expect(getByTestId(`${prefix}pinch-da`)).toHaveTextContent(`30,90`)
})
test('passing the 180° angle between clockwise between two move events should account for a new turn', () => {
fireEvent.pointerMove(element, { pointerId: 32, clientX: 3, clientY: -30, buttons: 1 })
fireEvent.pointerMove(element, { pointerId: 32, clientX: -3, clientY: -30, buttons: 1 })
expect(getByTestId(`${prefix}pinch-turns`)).toHaveTextContent(`1`)
})
test('canceling the gesture should cancel the gesture in the next RAF tick', async () => {
rerender(<Component gestures={['Pinch']} canceled />)
fireEvent.pointerMove(element, { pointerId: 32, clientX: -3, clientY: -30, buttons: 1 })
await waitFor(() => {
expect(getByTestId(`${prefix}pinch-canceled`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}pinch-pinching`)).toHaveTextContent('false')
})
fireEvent.pointerUp(element, { pointerId: 31 })
fireEvent.pointerUp(element, { pointerId: 32 })
})
test('disabling all gestures should prevent state from updating', () => {
rerender(<Component gestures={['Pinch']} config={{ enabled: false }} />)
fireEvent.pointerDown(element, { pointerId: 41, clientX: 0, clientY: 0, buttons: 1 })
fireEvent.pointerDown(element, { pointerId: 42, clientX: 0, clientY: 40, buttons: 1 })
expect(getByTestId(`${prefix}pinch-pinching`)).toHaveTextContent('false')
fireEvent.pointerUp(element, { pointerId: 41 })
fireEvent.pointerUp(element, { pointerId: 42 })
})
test('disabling the pinch gesture should prevent state from updating', () => {
rerender(<Component gestures={['Pinch']} config={{ pinch: { enabled: false } }} />)
fireEvent.pointerDown(element, { pointerId: 51, clientX: 0, clientY: 0, buttons: 1 })
fireEvent.pointerDown(element, { pointerId: 52, clientX: 0, clientY: 40, buttons: 1 })
expect(getByTestId(`${prefix}pinch-pinching`)).toHaveTextContent('false')
fireEvent.pointerUp(element, { pointerId: 51 })
fireEvent.pointerUp(element, { pointerId: 52 })
})
// this test uses bindArgs which are only accessible when attaching handlers to the component
// (ie without the domTarget option)
if (_testName === 'attached to component') {
test(`scaleBounds and angleBounds should define _bounds in state`, () => {
rerender(
<Component
gestures={['Pinch']}
bindArgs={[2]}
config={{
pinch: {
scaleBounds: ({ args: [i] }) => ({ min: i * 0.25, max: i * 2 }),
angleBounds: ({ args: [i] }) => ({ min: i * -300 })
}
}}
/>
)
fireEvent.pointerDown(element, { pointerId: 61, clientX: 0, clientY: 0, buttons: 1 })
fireEvent.pointerDown(element, { pointerId: 62, clientX: 0, clientY: 40, buttons: 1 })
expect(getByTestId(`${prefix}pinch-_bounds`)).toHaveTextContent('0.5,4,-600,Infinity')
})
}
})
|
7,240 | 0 | petrpan-code/pmndrs/use-gesture | petrpan-code/pmndrs/use-gesture/test/scroll.test.tsx | import React from 'react'
import { render, cleanup, fireEvent, createEvent, waitFor } from '@testing-library/react'
import '@testing-library/jest-dom/extend-expect'
import Interactive from './components/Interactive'
import InteractiveDom from './components/InteractiveDom'
import { InteractiveType } from './components/types'
afterAll(cleanup)
describe.each([
['attached to component', Interactive, ''],
['attached to node', InteractiveDom, 'dom-']
])('testing onScroll %s)', (_testName, C, prefix) => {
const Component = C as InteractiveType
const { getByTestId, rerender } = render(<Component gestures={['Scroll']} memoArg="memo" />)
const element = getByTestId(`${prefix}scroll-el`)
let delta_t: number
test('scroll event should initiate the gesture', async () => {
element.scrollLeft = 10
element.scrollTop = 30
const event = createEvent.scroll(element)
fireEvent(element, event)
delta_t = event.timeStamp
expect(getByTestId(`${prefix}scroll-active`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}scroll-scrolling`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}scroll-first`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}scroll-xy`)).toHaveTextContent('10,30')
expect(getByTestId(`${prefix}scroll-delta`)).toHaveTextContent('10,30')
expect(getByTestId(`${prefix}scroll-initial`)).toHaveTextContent('0,0')
})
test('initiating the gesture should fire onScrollStart', () => {
expect(getByTestId(`${prefix}scroll-start`)).toHaveTextContent(/^fired$/)
expect(getByTestId(`${prefix}scroll-end`)).toHaveTextContent(/^not fired$/)
})
test('testing memo value is passed', () => {
expect(getByTestId(`${prefix}scroll-memo`)).toHaveTextContent('memo')
})
test('the second scroll event should set first to false', () => {
element.scrollLeft = 40
element.scrollTop = 50
const event = createEvent.scroll(element)
fireEvent(element, event)
delta_t = event.timeStamp - delta_t
expect(getByTestId(`${prefix}scroll-first`)).toHaveTextContent('false')
expect(getByTestId(`${prefix}scroll-last`)).toHaveTextContent('false')
})
test('xy should update to latest scrollLeft and scrollTop', () => {
expect(getByTestId(`${prefix}scroll-xy`)).toHaveTextContent('40,50')
expect(getByTestId(`${prefix}scroll-delta`)).toHaveTextContent('30,20')
expect(getByTestId(`${prefix}scroll-movement`)).toHaveTextContent('40,50')
})
test('kinematics should update', () => {
expect(getByTestId(`${prefix}scroll-velocity`)).toHaveTextContent(`${30 / delta_t},${20 / delta_t}`)
})
test('the last scroll event should debounce and terminate the gesture', async () => {
await waitFor(() => {
expect(getByTestId(`${prefix}scroll-last`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}scroll-active`)).toHaveTextContent('false')
expect(getByTestId(`${prefix}scroll-velocity`)).toHaveTextContent(`${30 / delta_t},${20 / delta_t}`)
expect(getByTestId(`${prefix}scroll-scrolling`)).toHaveTextContent('false')
})
})
test('terminating the gesture should fire onScrollEnd', async () => {
await waitFor(() => expect(getByTestId(`${prefix}scroll-end`)).toHaveTextContent(/^fired$/))
})
test('disabling all gestures should prevent state from updating', () => {
rerender(<Component gestures={['Scroll']} config={{ enabled: false }} />)
fireEvent.scroll(element)
expect(getByTestId(`${prefix}scroll-scrolling`)).toHaveTextContent('false')
})
test('disabling the scroll gesture should prevent state from updating', () => {
rerender(<Component gestures={['Scroll']} config={{ scroll: { enabled: false } }} />)
fireEvent.scroll(element)
expect(getByTestId(`${prefix}scroll-scrolling`)).toHaveTextContent('false')
})
})
|
7,242 | 0 | petrpan-code/pmndrs/use-gesture | petrpan-code/pmndrs/use-gesture/test/wheel.test.tsx | import React from 'react'
import { render, cleanup, fireEvent, createEvent, waitFor } from '@testing-library/react'
import '@testing-library/jest-dom/extend-expect'
import Interactive from './components/Interactive'
import InteractiveDom from './components/InteractiveDom'
import { InteractiveType } from './components/types'
import { later } from './utils'
afterAll(cleanup)
describe.each([
['attached to component', Interactive, ''],
['attached to node', InteractiveDom, 'dom-']
])('testing onWheel %s)', (_testName, C, prefix) => {
const Component = C as InteractiveType
const { getByTestId, rerender } = render(<Component gestures={['Wheel']} memoArg="memo" />)
const element = getByTestId(`${prefix}wheel-el`)
let delta_t: number
test('wheel event should initiate the gesture', () => {
const event = createEvent.wheel(element, { deltaX: 1, deltaY: -1 })
fireEvent(element, event)
delta_t = event.timeStamp
expect(getByTestId(`${prefix}wheel-active`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}wheel-wheeling`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}wheel-first`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}wheel-delta`)).toHaveTextContent('1,-1')
expect(getByTestId(`${prefix}wheel-initial`)).toHaveTextContent('0,0')
})
test('initiating the gesture should fire onWheelStart', () => {
expect(getByTestId(`${prefix}wheel-start`)).toHaveTextContent(/^fired$/)
expect(getByTestId(`${prefix}wheel-end`)).toHaveTextContent(/^not fired$/)
})
test('testing memo value is passed', () => {
expect(getByTestId(`${prefix}wheel-memo`)).toHaveTextContent('memo')
})
test('the second wheel event should set first to false', () => {
const event = createEvent.wheel(element, { deltaX: 4, deltaY: -5 })
fireEvent(element, event)
delta_t = event.timeStamp - delta_t
expect(getByTestId(`${prefix}wheel-first`)).toHaveTextContent('false')
expect(getByTestId(`${prefix}wheel-last`)).toHaveTextContent('false')
})
test('xy should add wheel event offset', () => {
expect(getByTestId(`${prefix}wheel-delta`)).toHaveTextContent('4,-5')
expect(getByTestId(`${prefix}wheel-offset`)).toHaveTextContent('5,-6')
})
test('kinematics should update', () => {
expect(getByTestId(`${prefix}wheel-direction`)).toHaveTextContent(`1,-1`)
expect(getByTestId(`${prefix}wheel-velocity`)).toHaveTextContent(`${4 / delta_t},${5 / delta_t}`)
})
test('the last wheel event should debounce and terminate the gesture', async () => {
await waitFor(() => {
expect(getByTestId(`${prefix}wheel-last`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}wheel-active`)).toHaveTextContent('false')
expect(getByTestId(`${prefix}wheel-velocity`)).toHaveTextContent(`${4 / delta_t},${5 / delta_t}`)
expect(getByTestId(`${prefix}wheel-wheeling`)).toHaveTextContent('false')
})
})
test('terminating the gesture should fire onWheelEnd', async () => {
await waitFor(() => expect(getByTestId(`${prefix}wheel-end`)).toHaveTextContent(/^fired$/))
})
test('wheeling again should restart the gesture', async () => {
fireEvent.wheel(element, { deltaX: 10, deltaY: 0 })
expect(getByTestId(`${prefix}wheel-first`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}wheel-lastOffset`)).toHaveTextContent('5,-6')
await waitFor(() => expect(getByTestId(`${prefix}wheel-active`)).toHaveTextContent('false'))
})
test(`applying an axis SHOULDN'T start the gesture if gesture is not detected first in the right axis`, async () => {
rerender(<Component gestures={['Wheel']} config={{ wheel: { axis: 'x' } }} />)
fireEvent.wheel(element, { deltaX: 0, deltaY: 10 })
fireEvent.wheel(element, { deltaX: 4, deltaY: 0 })
expect(getByTestId(`${prefix}wheel-active`)).toHaveTextContent('false')
// allow gesture to finish
await later(200)
})
test(`applying an axis SHOULD start the gesture if gesture is detected in the right axis`, async () => {
fireEvent.wheel(element, { deltaX: 10, deltaY: 0 })
fireEvent.wheel(element, { deltaX: 0, deltaY: 4 })
fireEvent.wheel(element, { deltaX: 3, deltaY: 0 })
expect(getByTestId(`${prefix}wheel-wheeling`)).toHaveTextContent('true')
expect(getByTestId(`${prefix}wheel-movement`)).toHaveTextContent('13,0')
await waitFor(() => expect(getByTestId(`${prefix}wheel-wheeling`)).toHaveTextContent('false'))
})
test('disabling all gestures should prevent state from updating', async () => {
rerender(<Component gestures={['Wheel']} config={{ enabled: false }} />)
fireEvent.wheel(element)
expect(getByTestId(`${prefix}wheel-wheeling`)).toHaveTextContent('false')
})
test('disabling the wheel gesture should prevent state from updating', () => {
rerender(<Component gestures={['Wheel']} config={{ wheel: { enabled: false } }} />)
fireEvent.wheel(element)
expect(getByTestId(`${prefix}wheel-wheeling`)).toHaveTextContent('false')
})
})
|
7,358 | 0 | petrpan-code/pmndrs/valtio | petrpan-code/pmndrs/valtio/tests/async.test.tsx | import { StrictMode, Suspense } from 'react'
import { fireEvent, render, waitFor } from '@testing-library/react'
import { it } from 'vitest'
import { proxy, useSnapshot } from 'valtio'
const sleep = (ms: number) =>
new Promise((resolve) => {
setTimeout(resolve, ms)
})
it('delayed increment', async () => {
const state = proxy<any>({ count: 0 })
const delayedIncrement = () => {
const nextCount = state.count + 1
state.count = sleep(300).then(() => nextCount)
}
const Counter = () => {
const snap = useSnapshot(state)
return (
<>
<div>count: {snap.count}</div>
<button onClick={delayedIncrement}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('button'))
await findByText('loading')
await findByText('count: 1')
})
it('delayed object', async () => {
const state = proxy<any>({ object: { text: 'none' } })
const delayedObject = () => {
state.object = sleep(300).then(() => ({ text: 'hello' }))
}
const Counter = () => {
const snap = useSnapshot(state)
return (
<>
<div>text: {snap.object.text}</div>
<button onClick={delayedObject}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('text: none')
fireEvent.click(getByText('button'))
await findByText('loading')
await findByText('text: hello')
})
it('delayed object update fulfilled', async () => {
const state = proxy<any>({
object: sleep(300).then(() => ({ text: 'counter', count: 0 })),
})
const updateObject = () => {
state.object = state.object.then((v: any) =>
sleep(300).then(() => ({ ...v, count: v.count + 1 })),
)
}
const Counter = () => {
const snap = useSnapshot(state)
return (
<>
<div>text: {snap.object.text}</div>
<div>count: {snap.object.count}</div>
<button onClick={updateObject}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('loading')
await waitFor(() => {
getByText('text: counter')
getByText('count: 0')
})
fireEvent.click(getByText('button'))
await findByText('loading')
await waitFor(() => {
getByText('text: counter')
getByText('count: 1')
})
})
it('delayed falsy value', async () => {
const state = proxy<any>({ value: true })
const delayedValue = () => {
state.value = sleep(300).then(() => null)
}
const Counter = () => {
const snap = useSnapshot(state)
return (
<>
<div>value: {String(snap.value)}</div>
<button onClick={delayedValue}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('value: true')
fireEvent.click(getByText('button'))
await findByText('loading')
await findByText('value: null')
})
|
7,359 | 0 | petrpan-code/pmndrs/valtio | petrpan-code/pmndrs/valtio/tests/basic.test.tsx | import { StrictMode, useEffect, useRef, useState } from 'react'
import { fireEvent, render, waitFor } from '@testing-library/react'
import { expect, it, vi } from 'vitest'
import { proxy, snapshot, useSnapshot } from 'valtio'
it('simple counter', async () => {
const obj = proxy({ count: 0 })
const Counter = () => {
const snap = useSnapshot(obj)
return (
<>
<div>count: {snap.count}</div>
<button onClick={() => ++obj.count}>button</button>
</>
)
}
const { getByText, findByText, unmount } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('button'))
await findByText('count: 1')
unmount()
})
it('no extra re-renders (commits)', async () => {
const obj = proxy({ count: 0, count2: 0 })
const Counter = () => {
const snap = useSnapshot(obj)
const commitsRef = useRef(1)
useEffect(() => {
commitsRef.current += 1
})
return (
<>
<div>
count: {snap.count} ({commitsRef.current})
</div>
<button onClick={() => ++obj.count}>button</button>
</>
)
}
const Counter2 = () => {
const snap = useSnapshot(obj)
const commitsRef = useRef(1)
useEffect(() => {
commitsRef.current += 1
})
return (
<>
<div>
count2: {snap.count2} ({commitsRef.current})
</div>
<button onClick={() => ++obj.count2}>button2</button>
</>
)
}
const { getByText } = render(
<>
<Counter />
<Counter2 />
</>,
)
await waitFor(() => {
getByText('count: 0 (1)')
getByText('count2: 0 (1)')
})
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('count: 1 (2)')
getByText('count2: 0 (1)')
})
fireEvent.click(getByText('button2'))
await waitFor(() => {
getByText('count: 1 (2)')
getByText('count2: 1 (2)')
})
})
it('no extra re-renders (render func calls in non strict mode)', async () => {
const obj = proxy({ count: 0, count2: 0 })
const renderFn = vi.fn()
const Counter = () => {
const snap = useSnapshot(obj)
renderFn(snap.count)
return (
<>
<div>count: {snap.count}</div>
<button onClick={() => ++obj.count}>button</button>
</>
)
}
const renderFn2 = vi.fn()
const Counter2 = () => {
const snap = useSnapshot(obj)
renderFn2(snap.count2)
return (
<>
<div>count2: {snap.count2}</div>
<button onClick={() => ++obj.count2}>button2</button>
</>
)
}
const { getByText } = render(
<>
<Counter />
<Counter2 />
</>,
)
await waitFor(() => {
getByText('count: 0')
getByText('count2: 0')
})
expect(renderFn).toBeCalledTimes(1)
expect(renderFn).lastCalledWith(0)
expect(renderFn2).toBeCalledTimes(1)
expect(renderFn2).lastCalledWith(0)
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('count: 1')
getByText('count2: 0')
})
expect(renderFn).toBeCalledTimes(2)
expect(renderFn).lastCalledWith(1)
expect(renderFn2).toBeCalledTimes(1)
expect(renderFn2).lastCalledWith(0)
fireEvent.click(getByText('button2'))
await waitFor(() => {
getByText('count: 1')
getByText('count2: 1')
})
expect(renderFn).toBeCalledTimes(2)
expect(renderFn).lastCalledWith(1)
expect(renderFn2).toBeCalledTimes(2)
expect(renderFn2).lastCalledWith(1)
fireEvent.click(getByText('button2'))
await waitFor(() => {
getByText('count: 1')
getByText('count2: 2')
})
expect(renderFn).toBeCalledTimes(2)
expect(renderFn).lastCalledWith(1)
expect(renderFn2).toBeCalledTimes(3)
expect(renderFn2).lastCalledWith(2)
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('count: 2')
getByText('count2: 2')
})
expect(renderFn).toBeCalledTimes(3)
expect(renderFn).lastCalledWith(2)
expect(renderFn2).toBeCalledTimes(3)
expect(renderFn2).lastCalledWith(2)
})
it('object in object', async () => {
const obj = proxy({ object: { count: 0 } })
const Counter = () => {
const snap = useSnapshot(obj)
return (
<>
<div>count: {snap.object.count}</div>
<button onClick={() => ++obj.object.count}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('button'))
await findByText('count: 1')
})
it('array in object', async () => {
const obj = proxy({ counts: [0, 1, 2] })
const Counter = () => {
const snap = useSnapshot(obj)
return (
<>
<div>counts: {snap.counts.join(',')}</div>
<button onClick={() => obj.counts.push(obj.counts.length)}>
button
</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('counts: 0,1,2')
fireEvent.click(getByText('button'))
await findByText('counts: 0,1,2,3')
})
it('array pop and splice', async () => {
const arr = proxy([0, 1, 2])
const Counter = () => {
const snap = useSnapshot(arr)
return (
<>
<div>counts: {snap.join(',')}</div>
<button onClick={() => arr.pop()}>button</button>
<button onClick={() => arr.splice(1, 0, 10, 11)}>button2</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('counts: 0,1,2')
fireEvent.click(getByText('button'))
await findByText('counts: 0,1')
fireEvent.click(getByText('button2'))
await findByText('counts: 0,10,11,1')
})
it('array length after direct assignment', async () => {
const obj = proxy({ counts: [0, 1, 2] })
const Counter = () => {
const snap = useSnapshot(obj)
return (
<>
<div>counts: {snap.counts.join(',')}</div>
<div>length: {snap.counts.length}</div>
<button
onClick={() => (obj.counts[obj.counts.length] = obj.counts.length)}
>
increment
</button>
<button
onClick={() =>
(obj.counts[obj.counts.length + 5] = obj.counts.length + 5)
}
>
jump
</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('counts: 0,1,2')
fireEvent.click(getByText('increment'))
await findByText('counts: 0,1,2,3')
fireEvent.click(getByText('jump'))
await findByText('counts: 0,1,2,3,,,,,,9')
})
it('deleting property', async () => {
const obj = proxy<{ count?: number }>({ count: 1 })
const Counter = () => {
const snap = useSnapshot(obj)
return (
<>
<div>count: {snap.count ?? 'none'}</div>
<button onClick={() => delete obj.count}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 1')
fireEvent.click(getByText('button'))
await findByText('count: none')
})
it('circular object', async () => {
const obj = proxy<any>({ object: {} })
obj.object = obj
obj.object.count = 0
const Counter = () => {
const snap = useSnapshot(obj) as any
return (
<>
<div>count: {snap.count}</div>
<button onClick={() => ++obj.count}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('button'))
await findByText('count: 1')
})
it('circular object with non-proxy object (#375)', async () => {
const initialObject = { count: 0 }
const state: any = proxy(initialObject)
state.obj = initialObject
const Counter = () => {
const snap = useSnapshot(state)
return <div>count: {snap.obj ? 1 : snap.count}</div>
}
const { findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 1')
})
it('render from outside', async () => {
const obj = proxy({ count: 0, anotherCount: 0 })
const Counter = () => {
const [show, setShow] = useState(false)
const snap = useSnapshot(obj)
return (
<>
{show ? (
<div>count: {snap.count}</div>
) : (
<div>anotherCount: {snap.anotherCount}</div>
)}
<button onClick={() => ++obj.count}>button</button>
<button onClick={() => setShow((x) => !x)}>toggle</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('anotherCount: 0')
fireEvent.click(getByText('button'))
fireEvent.click(getByText('toggle'))
await findByText('count: 1')
})
it('counter with sync option', async () => {
const obj = proxy({ count: 0 })
const Counter = () => {
const snap = useSnapshot(obj, { sync: true })
const commitsRef = useRef(1)
useEffect(() => {
commitsRef.current += 1
})
return (
<>
<div>
count: {snap.count} ({commitsRef.current})
</div>
<button onClick={() => ++obj.count}>button</button>
</>
)
}
const { getByText, findByText } = render(
<>
<Counter />
</>,
)
await findByText('count: 0 (1)')
fireEvent.click(getByText('button'))
await findByText('count: 1 (2)')
fireEvent.click(getByText('button'))
await findByText('count: 2 (3)')
})
it('support undefined property (#439)', async () => {
const obj = proxy({ prop: undefined })
expect('prop' in obj).toBe(true)
const Component = () => {
const snap = useSnapshot(obj)
return <div>has prop: {JSON.stringify('prop' in snap)}</div>
}
const { findByText } = render(
<StrictMode>
<Component />
</StrictMode>,
)
await findByText('has prop: true')
})
it('sync snapshot between nested components (#460)', async () => {
const obj = proxy<{
id: 'prop1' | 'prop2'
prop1: string
prop2?: string
}>({ id: 'prop1', prop1: 'value1' })
const Child = ({ id }: { id: 'prop1' | 'prop2' }) => {
const snap = useSnapshot(obj)
return <div>Child: {snap[id]}</div>
}
const handleClick = () => {
obj.prop2 = 'value2'
obj.id = 'prop2'
}
const Parent = () => {
const snap = useSnapshot(obj)
return (
<>
<div>Parent: {snap[snap.id]}</div>
<Child id={snap.id} />
<button onClick={handleClick}>button</button>
</>
)
}
const { getByText } = render(
<StrictMode>
<Parent />
</StrictMode>,
)
await waitFor(() => {
getByText('Parent: value1')
getByText('Child: value1')
})
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('Parent: value2')
getByText('Child: value2')
})
})
it('respects property enumerability (#726)', async () => {
const x = proxy(Object.defineProperty({ a: 1 }, 'b', { value: 2 }))
expect(Object.keys(snapshot(x))).toEqual(Object.keys(x))
})
|
7,360 | 0 | petrpan-code/pmndrs/valtio | petrpan-code/pmndrs/valtio/tests/class.test.tsx | import { StrictMode, useEffect, useRef } from 'react'
import { fireEvent, render, waitFor } from '@testing-library/react'
import { it } from 'vitest'
import { proxy, useSnapshot } from 'valtio'
it('simple class without methods', async () => {
class CountClass {
public count: number
constructor() {
this.count = 0
}
}
const obj = proxy(new CountClass())
const Counter = () => {
const snap = useSnapshot(obj)
return (
<>
<div>count: {snap.count}</div>
<button onClick={() => ++obj.count}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('button'))
await findByText('count: 1')
})
it('no extra re-renders with class', async () => {
class CountClass {
public count: number
public count2: number
constructor() {
this.count = 0
this.count2 = 0
}
}
const obj = proxy(new CountClass())
const Counter = () => {
const snap = useSnapshot(obj)
const commitsRef = useRef(0)
useEffect(() => {
commitsRef.current += 1
})
return (
<>
<div>
count: {snap.count} ({commitsRef.current})
</div>
<button onClick={() => ++obj.count}>button</button>
</>
)
}
const Counter2 = () => {
const snap = useSnapshot(obj)
const commitsRef = useRef(0)
useEffect(() => {
commitsRef.current += 1
})
return (
<>
<div>
count2: {snap.count2} ({commitsRef.current})
</div>
<button onClick={() => ++obj.count2}>button2</button>
</>
)
}
const { getByText } = render(
<>
<Counter />
<Counter2 />
</>,
)
await waitFor(() => {
getByText('count: 0 (0)')
getByText('count2: 0 (0)')
})
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('count: 1 (1)')
getByText('count2: 0 (0)')
})
fireEvent.click(getByText('button2'))
await waitFor(() => {
getByText('count: 1 (1)')
getByText('count2: 1 (1)')
})
})
it('inherited class without methods', async () => {
class BaseClass {
public count: number
constructor() {
this.count = 0
}
}
class CountClass extends BaseClass {
public count2: number
constructor() {
super()
this.count2 = 0
}
}
const obj = proxy(new CountClass())
const Counter = () => {
const snap = useSnapshot(obj)
return (
<>
<div>count: {snap.count}</div>
<button onClick={() => ++obj.count}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('button'))
await findByText('count: 1')
})
it('class with a method', async () => {
class CountClass {
public count: number
constructor() {
this.count = 0
}
public doubled() {
return this.count * 2
}
}
const obj = proxy(new CountClass())
const Counter = () => {
const snap = useSnapshot(obj)
const commitsRef = useRef(0)
useEffect(() => {
commitsRef.current += 1
})
return (
<>
<div>
doubled: {snap.doubled()} ({commitsRef.current})
</div>
<button onClick={() => ++obj.count}>button</button>
</>
)
}
const Counter2 = () => {
const snap = useSnapshot(obj)
const commitsRef = useRef(0)
useEffect(() => {
commitsRef.current += 1
})
return (
<div>
count: {snap.count} ({commitsRef.current})
</div>
)
}
const { getByText } = render(
<>
<Counter />
<Counter2 />
</>,
)
await waitFor(() => {
getByText('doubled: 0 (0)')
getByText('count: 0 (0)')
})
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('doubled: 2 (1)')
getByText('count: 1 (1)')
})
})
it('inherited class with a method', async () => {
class BaseClass {
public count: number
constructor() {
this.count = 0
}
public doubled() {
return this.count * 2
}
}
class CountClass extends BaseClass {
public count2: number
constructor() {
super()
this.count2 = 0
}
}
const obj = proxy(new CountClass())
const Counter = () => {
const snap = useSnapshot(obj)
const commitsRef = useRef(0)
useEffect(() => {
commitsRef.current += 1
})
return (
<>
<div>
doubled: {snap.doubled()} ({commitsRef.current})
</div>
<button onClick={() => ++obj.count}>button</button>
</>
)
}
const Counter2 = () => {
const snap = useSnapshot(obj)
const commitsRef = useRef(0)
useEffect(() => {
commitsRef.current += 1
})
return (
<>
<div>
count2: {snap.count2} ({commitsRef.current})
</div>
<button onClick={() => ++obj.count2}>button2</button>
</>
)
}
const { getByText } = render(
<>
<Counter />
<Counter2 />
</>,
)
await waitFor(() => {
getByText('doubled: 0 (0)')
getByText('count2: 0 (0)')
})
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('doubled: 2 (1)')
getByText('count2: 0 (0)')
})
fireEvent.click(getByText('button2'))
await waitFor(() => {
getByText('doubled: 2 (1)')
getByText('count2: 1 (1)')
})
})
it('no extra re-renders with getters', async () => {
class CountClass {
public count: number
public count2: number
constructor() {
this.count = 0
this.count2 = 0
}
get count1() {
return this.count
}
get sum() {
return this.count + this.count2
}
}
const obj = proxy(new CountClass())
const Counter = () => {
const snap = useSnapshot(obj)
const commitsRef = useRef(0)
useEffect(() => {
commitsRef.current += 1
})
return (
<>
<div>
count: {snap.count1} ({commitsRef.current})
</div>
<button onClick={() => ++obj.count}>button</button>
</>
)
}
const Counter2 = () => {
const snap = useSnapshot(obj)
const commitsRef = useRef(0)
useEffect(() => {
commitsRef.current += 1
})
return (
<>
<div>
sum: {snap.sum} ({commitsRef.current})
</div>
<button onClick={() => ++obj.count2}>button2</button>
</>
)
}
const { getByText } = render(
<>
<Counter />
<Counter2 />
</>,
)
await waitFor(() => {
getByText('count: 0 (0)')
getByText('sum: 0 (0)')
})
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('count: 1 (1)')
getByText('sum: 1 (1)')
})
fireEvent.click(getByText('button2'))
await waitFor(() => {
getByText('count: 1 (1)')
getByText('sum: 2 (2)')
})
})
|
7,361 | 0 | petrpan-code/pmndrs/valtio | petrpan-code/pmndrs/valtio/tests/computed.test.tsx | import { StrictMode, Suspense } from 'react'
import { fireEvent, render } from '@testing-library/react'
import { memoize } from 'proxy-memoize'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { proxy, snapshot, subscribe, useSnapshot } from 'valtio'
import { addComputed, proxyWithComputed, subscribeKey } from 'valtio/utils'
const consoleWarn = console.warn
beforeEach(() => {
console.warn = vi.fn((message: string) => {
if (message.startsWith('addComputed is deprecated.')) {
return
}
consoleWarn(message)
})
})
afterEach(() => {
console.warn = consoleWarn
})
const sleep = (ms: number) =>
new Promise((resolve) => {
setTimeout(resolve, ms)
})
describe('proxyWithComputed', () => {
it('simple computed getters', async () => {
const computeDouble = vi.fn((x: number) => x * 2)
const state = proxyWithComputed(
{
text: '',
count: 0,
},
{
doubled: { get: memoize((snap) => computeDouble(snap.count)) },
},
)
const callback = vi.fn()
subscribe(state, callback)
expect(snapshot(state)).toMatchObject({ text: '', count: 0, doubled: 0 })
expect(computeDouble).toBeCalledTimes(1)
expect(callback).toBeCalledTimes(0)
state.count += 1
await Promise.resolve()
expect(snapshot(state)).toMatchObject({ text: '', count: 1, doubled: 2 })
expect(computeDouble).toBeCalledTimes(2)
expect(callback).toBeCalledTimes(1)
state.text = 'a'
await Promise.resolve()
expect(snapshot(state)).toMatchObject({ text: 'a', count: 1, doubled: 2 })
expect(computeDouble).toBeCalledTimes(2)
expect(callback).toBeCalledTimes(2)
})
it('computed getters and setters', async () => {
const computeDouble = vi.fn((x: number) => x * 2)
const state = proxyWithComputed(
{
text: '',
count: 0,
},
{
doubled: {
get: memoize((snap) => computeDouble(snap.count)),
set: (state, newValue: number) => {
state.count = newValue / 2
},
},
},
)
expect(snapshot(state)).toMatchObject({ text: '', count: 0, doubled: 0 })
expect(computeDouble).toBeCalledTimes(1)
state.count += 1
await Promise.resolve()
expect(snapshot(state)).toMatchObject({ text: '', count: 1, doubled: 2 })
expect(computeDouble).toBeCalledTimes(2)
state.doubled = 1
await Promise.resolve()
expect(snapshot(state)).toMatchObject({ text: '', count: 0.5, doubled: 1 })
expect(computeDouble).toBeCalledTimes(3)
state.text = 'a'
await Promise.resolve()
expect(snapshot(state)).toMatchObject({ text: 'a', count: 0.5, doubled: 1 })
expect(computeDouble).toBeCalledTimes(3)
})
it('computed setters with object and array', async () => {
const state = proxyWithComputed(
{
obj: { a: 1 },
arr: [2],
},
{
object: {
get: memoize((snap) => snap.obj),
set: (state, newValue: any) => {
state.obj = newValue
},
},
array: {
get: (snap) => snap.arr,
set: (state, newValue: any) => {
state.arr = newValue
},
},
},
)
expect(snapshot(state)).toMatchObject({
obj: { a: 1 },
arr: [2],
object: { a: 1 },
array: [2],
})
state.object = { a: 2 }
state.array = [3]
await Promise.resolve()
expect(snapshot(state)).toMatchObject({
obj: { a: 2 },
arr: [3],
object: { a: 2 },
array: [3],
})
})
it('render computed getter with condition (#435)', async () => {
const state = proxyWithComputed(
{
texts: [] as string[],
filter: '',
},
{
filtered: memoize((snap) => {
if (!snap.filter) return snap.texts
return snap.texts.filter((text) => !text.includes(snap.filter))
}),
},
)
const Component = () => {
const snap = useSnapshot(state)
return (
<>
<div>filtered: [{snap.filtered.join(',')}]</div>
<button onClick={() => (state.texts = ['foo'])}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Component />
</StrictMode>,
)
await findByText('filtered: []')
fireEvent.click(getByText('button'))
await findByText('filtered: [foo]')
})
})
describe('DEPRECATED addComputed', () => {
it('simple addComputed', async () => {
const computeDouble = vi.fn((x: number) => x * 2)
const state = proxy({
text: '',
count: 0,
})
addComputed(state, {
doubled: (snap) => computeDouble(snap.count),
})
const callback = vi.fn()
subscribe(state, callback)
expect(snapshot(state)).toMatchObject({ text: '', count: 0, doubled: 0 })
expect(computeDouble).toBeCalledTimes(1)
expect(callback).toBeCalledTimes(0)
state.count += 1
await Promise.resolve()
expect(snapshot(state)).toMatchObject({ text: '', count: 1, doubled: 2 })
expect(computeDouble).toBeCalledTimes(2)
await Promise.resolve()
expect(callback).toBeCalledTimes(1)
state.text = 'a'
await Promise.resolve()
expect(snapshot(state)).toMatchObject({ text: 'a', count: 1, doubled: 2 })
// This can't pass with derive emulation: expect(computeDouble).toBeCalledTimes(2)
expect(callback).toBeCalledTimes(2)
})
it('async addComputed', async () => {
const state = proxy({ count: 0 })
addComputed(state, {
delayedCount: async (snap) => {
await sleep(300)
return snap.count + 1
},
})
const Counter = () => {
const snap = useSnapshot(
state as { count: number; delayedCount: Promise<number> },
)
return (
<>
<div>
count: {snap.count}, delayedCount: {snap.delayedCount}
</div>
<button onClick={() => ++state.count}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('loading')
await findByText('count: 0, delayedCount: 1')
fireEvent.click(getByText('button'))
await findByText('loading')
await findByText('count: 1, delayedCount: 2')
})
it('nested emulation with addComputed', async () => {
const computeDouble = vi.fn((x: number) => x * 2)
const state = proxy({ text: '', math: { count: 0 } })
addComputed(
state,
{
doubled: (snap) => computeDouble(snap.math.count),
},
state.math,
)
const callback = vi.fn()
subscribe(state, callback)
expect(snapshot(state)).toMatchObject({
text: '',
math: { count: 0, doubled: 0 },
})
expect(computeDouble).toBeCalledTimes(1)
expect(callback).toBeCalledTimes(0)
state.math.count += 1
await Promise.resolve()
expect(snapshot(state)).toMatchObject({
text: '',
math: { count: 1, doubled: 2 },
})
expect(computeDouble).toBeCalledTimes(2)
await Promise.resolve()
expect(callback).toBeCalledTimes(1)
state.text = 'a'
await Promise.resolve()
expect(snapshot(state)).toMatchObject({
text: 'a',
math: { count: 1, doubled: 2 },
})
// This can't pass with derive emulation: expect(computeDouble).toBeCalledTimes(2)
expect(callback).toBeCalledTimes(2)
})
it('addComputed with array.pop (#124)', async () => {
const state = proxy({
arr: [{ n: 1 }, { n: 2 }, { n: 3 }],
})
addComputed(state, {
nums: (snap) => snap.arr.map((item) => item.n),
})
expect(snapshot(state)).toMatchObject({
arr: [{ n: 1 }, { n: 2 }, { n: 3 }],
nums: [1, 2, 3],
})
state.arr.pop()
await Promise.resolve()
expect(snapshot(state)).toMatchObject({
arr: [{ n: 1 }, { n: 2 }],
nums: [1, 2],
})
})
})
describe('proxyWithComputed and subscribeKey', () => {
it('should call subscribeKey subscription when computed value changes?', async () => {
const state = proxyWithComputed(
{
count: 1,
},
{
doubled: (snap) => snap.count * 2,
},
)
const handler = vi.fn()
subscribeKey(state, 'doubled', handler)
state.count = 2
await Promise.resolve()
expect(handler).toBeCalledTimes(1)
})
})
|
7,362 | 0 | petrpan-code/pmndrs/valtio | petrpan-code/pmndrs/valtio/tests/derive.test.tsx | import { StrictMode, Suspense, useEffect, useRef } from 'react'
import { fireEvent, render } from '@testing-library/react'
import { describe, expect, it, vi } from 'vitest'
import { proxy, snapshot, subscribe, useSnapshot } from 'valtio'
import { derive, underive } from 'valtio/utils'
type DeriveGet = <T extends object>(proxyObject: T) => T
const sleep = (ms: number) =>
new Promise((resolve) => {
setTimeout(resolve, ms)
})
it('basic derive', async () => {
const computeDouble = vi.fn((x: number) => x * 2)
const state = proxy({
text: '',
count: 0,
})
const derived = derive({
doubled: (get) => computeDouble(get(state).count),
})
const callback = vi.fn()
subscribe(derived, callback)
expect(snapshot(derived)).toMatchObject({ doubled: 0 })
expect(computeDouble).toBeCalledTimes(1)
expect(callback).toBeCalledTimes(0)
state.count += 1
await Promise.resolve()
expect(snapshot(derived)).toMatchObject({ doubled: 2 })
expect(computeDouble).toBeCalledTimes(2)
await Promise.resolve()
expect(callback).toBeCalledTimes(1)
state.text = 'a'
await Promise.resolve()
expect(snapshot(derived)).toMatchObject({ doubled: 2 })
expect(computeDouble).toBeCalledTimes(3)
await Promise.resolve()
expect(callback).toBeCalledTimes(1)
})
it('derive another proxy', async () => {
const computeDouble = vi.fn((x: number) => x * 2)
const state = proxy({
text: '',
count: 0,
})
const anotherState = proxy({})
derive(
{
doubled: (get) => computeDouble(get(state).count),
},
{
proxy: anotherState,
},
)
const callback = vi.fn()
subscribe(anotherState, callback)
expect(snapshot(anotherState)).toMatchObject({ doubled: 0 })
expect(computeDouble).toBeCalledTimes(1)
expect(callback).toBeCalledTimes(0)
state.count += 1
await Promise.resolve()
expect(snapshot(anotherState)).toMatchObject({ doubled: 2 })
expect(computeDouble).toBeCalledTimes(2)
await Promise.resolve()
expect(callback).toBeCalledTimes(1)
state.text = 'a'
await Promise.resolve()
expect(snapshot(anotherState)).toMatchObject({ doubled: 2 })
expect(computeDouble).toBeCalledTimes(3)
await Promise.resolve()
expect(callback).toBeCalledTimes(1)
})
it('derive with self', async () => {
const computeDouble = vi.fn((x: number) => x * 2)
const state = proxy({
text: '',
count: 0,
})
derive(
{
doubled: (get) => computeDouble(get(state).count),
},
{
proxy: state,
},
)
const callback = vi.fn()
subscribe(state, callback)
expect(snapshot(state)).toMatchObject({ text: '', count: 0, doubled: 0 })
expect(computeDouble).toBeCalledTimes(1)
expect(callback).toBeCalledTimes(0)
state.count += 1
await Promise.resolve()
expect(snapshot(state)).toMatchObject({ text: '', count: 1, doubled: 2 })
expect(computeDouble).toBeCalledTimes(2)
await Promise.resolve()
expect(callback).toBeCalledTimes(1)
state.text = 'a'
await Promise.resolve()
expect(snapshot(state)).toMatchObject({ text: 'a', count: 1, doubled: 2 })
expect(computeDouble).toBeCalledTimes(3)
await Promise.resolve()
expect(callback).toBeCalledTimes(2)
})
it('derive with two dependencies', async () => {
const computeSum = vi.fn((x: number, y: number) => x + y)
const state1 = proxy({ count: 1 })
const state2 = proxy({ count: 10 })
const derived = derive({
sum: (get) => computeSum(get(state1).count, get(state2).count),
})
const callback = vi.fn()
subscribe(derived, callback)
expect(snapshot(derived)).toMatchObject({ sum: 11 })
expect(computeSum).toBeCalledTimes(1)
expect(callback).toBeCalledTimes(0)
state1.count += 1
await Promise.resolve()
expect(snapshot(derived)).toMatchObject({ sum: 12 })
expect(computeSum).toBeCalledTimes(2)
await Promise.resolve()
expect(callback).toBeCalledTimes(1)
state1.count += 1
state2.count += 10
await Promise.resolve()
expect(snapshot(derived)).toMatchObject({ sum: 23 })
expect(computeSum).toBeCalledTimes(3)
await Promise.resolve()
expect(callback).toBeCalledTimes(2)
})
it('async derive', async () => {
const state = proxy({ count: 0 })
derive(
{
delayedCount: async (get) => {
await sleep(300)
return get(state).count + 1
},
},
{ proxy: state },
)
const Counter = () => {
const snap = useSnapshot(
state as { count: number; delayedCount: Promise<number> },
)
return (
<>
<div>
count: {snap.count}, delayedCount: {snap.delayedCount}
</div>
<button onClick={() => ++state.count}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Suspense fallback="loading">
<Counter />
</Suspense>
</StrictMode>,
)
await findByText('loading')
await findByText('count: 0, delayedCount: 1')
fireEvent.click(getByText('button'))
await findByText('loading')
await findByText('count: 1, delayedCount: 2')
})
it('nested emulation with derive', async () => {
const computeDouble = vi.fn((x: number) => x * 2)
const state = proxy({ text: '', math: { count: 0 } })
derive(
{
doubled: (get) => computeDouble(get(state.math).count),
},
{ proxy: state.math, sync: true },
)
const callback = vi.fn()
subscribe(state, callback)
expect(snapshot(state)).toMatchObject({
text: '',
math: { count: 0, doubled: 0 },
})
expect(computeDouble).toBeCalledTimes(1)
expect(callback).toBeCalledTimes(0)
state.math.count += 1
await Promise.resolve()
expect(snapshot(state)).toMatchObject({
text: '',
math: { count: 1, doubled: 2 },
})
expect(computeDouble).toBeCalledTimes(2)
await Promise.resolve()
expect(callback).toBeCalledTimes(1)
state.text = 'a'
await Promise.resolve()
expect(snapshot(state)).toMatchObject({
text: 'a',
math: { count: 1, doubled: 2 },
})
expect(computeDouble).toBeCalledTimes(2)
await Promise.resolve()
expect(callback).toBeCalledTimes(2)
})
it('derive with array.pop', async () => {
const state = proxy({
arr: [{ n: 1 }, { n: 2 }, { n: 3 }],
})
derive(
{
nums: (get) => get(state.arr).map((item) => item.n),
},
{ proxy: state },
)
expect(snapshot(state)).toMatchObject({
arr: [{ n: 1 }, { n: 2 }, { n: 3 }],
nums: [1, 2, 3],
})
state.arr.pop()
await Promise.resolve()
expect(snapshot(state)).toMatchObject({
arr: [{ n: 1 }, { n: 2 }],
nums: [1, 2],
})
})
it('basic underive', async () => {
const computeDouble = vi.fn((x: number) => x * 2)
const state = proxy({ count: 0 })
const derived = derive({
doubled: (get) => computeDouble(get(state).count),
})
const callback = vi.fn()
subscribe(derived, callback)
expect(snapshot(derived)).toMatchObject({ doubled: 0 })
expect(computeDouble).toBeCalledTimes(1)
expect(callback).toBeCalledTimes(0)
state.count += 1
await Promise.resolve()
expect(snapshot(derived)).toMatchObject({ doubled: 2 })
expect(computeDouble).toBeCalledTimes(2)
await Promise.resolve()
expect(callback).toBeCalledTimes(1)
underive(derived)
state.count += 1
await Promise.resolve()
expect(snapshot(derived)).toMatchObject({ doubled: 2 })
expect(computeDouble).toBeCalledTimes(2)
await Promise.resolve()
expect(callback).toBeCalledTimes(1)
})
describe('glitch free', () => {
it('basic (#296)', async () => {
const state = proxy({ value: 0 })
const derived1 = derive({ value: (get) => get(state).value })
const derived2 = derive({ value: (get) => get(derived1).value })
const computeValue = vi.fn((get: DeriveGet) => {
const v0 = get(state).value
const v1 = get(derived1).value
const v2 = get(derived2).value
return `v0: ${v0}, v1: ${v1}, v2: ${v2}`
})
const derived3 = derive({ value: computeValue })
const App = () => {
const snap = useSnapshot(derived3)
const commitsRef = useRef(1)
useEffect(() => {
commitsRef.current += 1
})
return (
<>
value: {snap.value} (commits: {commitsRef.current})
<button onClick={() => ++state.value}>button</button>
</>
)
}
const { getByText, findByText } = render(
<>
<App />
</>,
)
await findByText('value: v0: 0, v1: 0, v2: 0 (commits: 1)')
expect(computeValue).toBeCalledTimes(1)
fireEvent.click(getByText('button'))
await findByText('value: v0: 1, v1: 1, v2: 1 (commits: 2)')
expect(computeValue).toBeCalledTimes(2)
})
it('same value', async () => {
const state = proxy({ value: 0 })
const derived1 = derive({
value: (get) => get(state).value * 0,
})
const derived2 = derive({
value: (get) => get(derived1).value * 0,
})
const computeValue = vi.fn((get: DeriveGet) => {
const v0 = get(state).value
const v1 = get(derived1).value
const v2 = get(derived2).value
return v0 + (v1 - v2)
})
const derived3 = derive({
value: (get) => computeValue(get),
})
const App = () => {
const snap = useSnapshot(derived3)
return (
<div>
value: {snap.value}
<button onClick={() => ++state.value}>button</button>
</div>
)
}
const { getByText, findByText } = render(
<StrictMode>
<App />
</StrictMode>,
)
await findByText('value: 0')
expect(computeValue).toBeCalledTimes(1)
fireEvent.click(getByText('button'))
await findByText('value: 1')
expect(computeValue).toBeCalledTimes(2)
})
it('double chain', async () => {
const state = proxy({ value: 0 })
const derived1 = derive({
value: (get) => get(state).value,
})
const derived2 = derive({
value: (get) => get(derived1).value,
})
const derived3 = derive({
value: (get) => get(derived2).value,
})
const computeValue = vi.fn((get: DeriveGet) => {
const v0 = get(state).value
const v1 = get(derived1).value
const v2 = get(derived2).value
const v3 = get(derived3).value
return v0 + (v1 - v2) + v3 * 0
})
const derived4 = derive({
value: (get) => computeValue(get),
})
const App = () => {
const snap = useSnapshot(derived4)
return (
<div>
value: {snap.value}
<button onClick={() => ++state.value}>button</button>
</div>
)
}
const { getByText, findByText } = render(
<StrictMode>
<App />
</StrictMode>,
)
await findByText('value: 0')
expect(computeValue).toBeCalledTimes(1)
fireEvent.click(getByText('button'))
await findByText('value: 1')
expect(computeValue).toBeCalledTimes(2)
})
})
describe('two derived properties', () => {
type State = {
a: number
derived1?: unknown
derived2?: unknown
}
it('two derived properties both returning primitive values (#349)', async () => {
const state: State = proxy({ a: 1 })
derive(
{
derived1: (get) => {
get(state).a
return 1
},
},
{ proxy: state },
)
derive(
{
derived2: (get) => {
get(state).a
return 1
},
},
{ proxy: state },
)
await Promise.resolve()
expect(state.derived1).toBeDefined()
expect(state.derived2).toBeDefined()
})
it('two derived properties both returning non primitive values, defined at the same time (#349)', async () => {
const state: State = proxy({ a: 1 })
derive(
{
derived1: (get) => {
get(state).a
return {}
},
derived2: (get) => {
get(state).a
return {}
},
},
{ proxy: state },
)
await Promise.resolve()
expect(state.derived1).toBeDefined()
expect(state.derived2).toBeDefined()
})
it('two derived properties both returning non primitive values (#349)', async () => {
const state: State = proxy({ a: 1 })
derive(
{
derived1: (get) => {
get(state).a
return {}
},
},
{ proxy: state },
)
derive(
{
derived2: (get) => {
get(state).a
return {}
},
},
{ proxy: state },
)
await Promise.resolve()
expect(state.derived1).toBeDefined()
expect(state.derived2).toBeDefined()
})
})
|
7,363 | 0 | petrpan-code/pmndrs/valtio | petrpan-code/pmndrs/valtio/tests/devtools.test.tsx | import { StrictMode, Suspense } from 'react'
import { act, fireEvent, render } from '@testing-library/react'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { proxy, useSnapshot } from 'valtio'
import { devtools } from 'valtio/utils'
let extensionSubscriber: ((message: any) => void) | undefined
const extension = {
subscribe: vi.fn((f: typeof extensionSubscriber) => {
extensionSubscriber = f
return () => {}
}),
unsubscribe: vi.fn(),
send: vi.fn(),
init: vi.fn(),
error: vi.fn(),
}
const extensionConnector = { connect: vi.fn(() => extension) }
;(window as any).__REDUX_DEVTOOLS_EXTENSION__ = extensionConnector
beforeEach(() => {
extensionConnector.connect.mockClear()
extension.subscribe.mockClear()
extension.unsubscribe.mockClear()
extension.send.mockClear()
extension.init.mockClear()
extension.error.mockClear()
extensionSubscriber = undefined
})
it('connects to the extension by initialiing', () => {
const obj = proxy({ count: 0 })
devtools(obj, { enabled: true })
const Counter = () => {
const snap = useSnapshot(obj)
return (
<>
<div>count: {snap.count}</div>
<button onClick={() => ++obj.count}>button</button>
</>
)
}
render(
<StrictMode>
<Counter />
</StrictMode>,
)
expect(extension.init).toHaveBeenLastCalledWith({ count: 0 })
})
describe('If there is no extension installed...', () => {
let savedConsoleWarn: any
beforeEach(() => {
savedConsoleWarn = console.warn
console.warn = vi.fn()
;(window as any).__REDUX_DEVTOOLS_EXTENSION__ = undefined
})
afterEach(() => {
console.warn = savedConsoleWarn
;(window as any).__REDUX_DEVTOOLS_EXTENSION__ = extensionConnector
})
it('does not throw', () => {
const obj = proxy({ count: 0 })
devtools(obj)
const Counter = () => {
const snap = useSnapshot(obj)
return (
<>
<div>count: {snap.count}</div>
<button onClick={() => ++obj.count}>button</button>
</>
)
}
expect(() => {
render(
<StrictMode>
<Counter />
</StrictMode>,
)
}).not.toThrow()
})
it('does not warn if enabled is undefined', () => {
const obj = proxy({ count: 0 })
devtools(obj)
const Counter = () => {
const snap = useSnapshot(obj)
return (
<>
<div>count: {snap.count}</div>
<button onClick={() => ++obj.count}>button</button>
</>
)
}
render(
<StrictMode>
<Counter />
</StrictMode>,
)
expect(console.warn).not.toBeCalled()
})
it('[DEV-ONLY] warns if enabled is true', () => {
const obj = proxy({ count: 0 })
devtools(obj, { enabled: true })
const Counter = () => {
const snap = useSnapshot(obj)
return (
<>
<div>count: {snap.count}</div>
<button onClick={() => ++obj.count}>button</button>
</>
)
}
render(
<StrictMode>
<Counter />
</StrictMode>,
)
expect(console.warn).toHaveBeenLastCalledWith(
'[Warning] Please install/enable Redux devtools extension',
)
})
it.skip('[PRD-ONLY] does not warn even if enabled is true', () => {
const obj = proxy({ count: 0 })
devtools(obj, { enabled: true })
const Counter = () => {
const snap = useSnapshot(obj)
return (
<>
<div>count: {snap.count}</div>
<button onClick={() => ++obj.count}>button</button>
</>
)
}
render(
<StrictMode>
<Counter />
</StrictMode>,
)
expect(console.warn).not.toBeCalled()
})
})
it('updating state should call devtools.send', async () => {
const obj = proxy({ count: 0 })
devtools(obj, { enabled: true })
const Counter = () => {
const snap = useSnapshot(obj)
return (
<>
<div>count: {snap.count}</div>
<button onClick={() => ++obj.count}>button</button>
</>
)
}
extension.send.mockClear()
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
expect(extension.send).toBeCalledTimes(0)
fireEvent.click(getByText('button'))
await findByText('count: 1')
expect(extension.send).toBeCalledTimes(1)
fireEvent.click(getByText('button'))
await findByText('count: 2')
expect(extension.send).toBeCalledTimes(2)
})
describe('when it receives an message of type...', () => {
it('updating state with ACTION', async () => {
const obj = proxy({ count: 0 })
devtools(obj, { enabled: true })
const Counter = () => {
const snap = useSnapshot(obj)
return (
<>
<div>count: {snap.count}</div>
<button onClick={() => ++obj.count}>button</button>
</>
)
}
extension.send.mockClear()
const { getByText, findByText } = render(
<StrictMode>
<Suspense fallback={'loading'}>
<Counter />
</Suspense>
</StrictMode>,
)
expect(extension.send).toBeCalledTimes(0)
fireEvent.click(getByText('button'))
await findByText('count: 1')
expect(extension.send).toBeCalledTimes(1)
act(() =>
(extensionSubscriber as (message: any) => void)({
type: 'ACTION',
payload: JSON.stringify({ count: 0 }),
}),
)
await findByText('count: 0')
expect(extension.send).toBeCalledTimes(2)
})
describe('DISPATCH and payload of type...', () => {
it('dispatch & COMMIT', async () => {
const obj = proxy({ count: 0 })
devtools(obj, { enabled: true })
const Counter = () => {
const snap = useSnapshot(obj)
return (
<>
<div>count: {snap.count}</div>
<button onClick={() => ++obj.count}>button</button>
</>
)
}
extension.send.mockClear()
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
expect(extension.send).toBeCalledTimes(0)
fireEvent.click(getByText('button'))
await findByText('count: 1')
expect(extension.send).toBeCalledTimes(1)
fireEvent.click(getByText('button'))
await findByText('count: 2')
act(() =>
(extensionSubscriber as (message: any) => void)({
type: 'DISPATCH',
payload: { type: 'COMMIT' },
}),
)
await findByText('count: 2')
expect(extension.init).toBeCalledWith({ count: 2 })
})
it('dispatch & IMPORT_STATE', async () => {
const obj = proxy({ count: 0 })
devtools(obj, { enabled: true })
const Counter = () => {
const snap = useSnapshot(obj)
return (
<>
<div>count: {snap.count}</div>
<button onClick={() => ++obj.count}>button</button>
</>
)
}
extension.send.mockClear()
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
const nextLiftedState = {
actionsById: ['5', '6'],
computedStates: [{ state: { count: 5 } }, { state: { count: 6 } }],
}
expect(extension.send).toBeCalledTimes(0)
fireEvent.click(getByText('button'))
await findByText('count: 1')
expect(extension.send).toBeCalledTimes(1)
fireEvent.click(getByText('button'))
await findByText('count: 2')
act(() =>
(extensionSubscriber as (message: any) => void)({
type: 'DISPATCH',
payload: { type: 'IMPORT_STATE', nextLiftedState },
}),
)
expect(extension.init).toBeCalledWith({ count: 5 })
await findByText('count: 6')
})
describe('JUMP_TO_STATE | JUMP_TO_ACTION...', () => {
it('time travelling', async () => {
const obj = proxy({ count: 0 })
devtools(obj, { enabled: true })
const Counter = () => {
const snap = useSnapshot(obj)
return (
<>
<div>count: {snap.count}</div>
<button onClick={() => ++obj.count}>button</button>
</>
)
}
extension.send.mockClear()
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
expect(extension.send).toBeCalledTimes(0)
fireEvent.click(getByText('button'))
await findByText('count: 1')
expect(extension.send).toBeCalledTimes(1)
act(() =>
(extensionSubscriber as (message: any) => void)({
type: 'DISPATCH',
payload: { type: 'JUMP_TO_ACTION' },
state: JSON.stringify({ count: 0 }),
}),
)
await findByText('count: 0')
expect(extension.send).toBeCalledTimes(1)
fireEvent.click(getByText('button'))
await findByText('count: 1')
fireEvent.click(getByText('button'))
await findByText('count: 2')
expect(extension.send).toBeCalledTimes(3)
})
})
})
})
|
7,364 | 0 | petrpan-code/pmndrs/valtio | petrpan-code/pmndrs/valtio/tests/getter.test.tsx | import { StrictMode } from 'react'
import { fireEvent, render, waitFor } from '@testing-library/react'
import { expect, it, vi } from 'vitest'
import { proxy, useSnapshot } from 'valtio'
it('simple object getters', async () => {
const computeDouble = vi.fn((x: number) => x * 2)
const state = proxy({
count: 0,
get doubled() {
return computeDouble(this.count)
},
})
const Counter = ({ name }: { name: string }) => {
const snap = useSnapshot(state)
return (
<>
<div>
{name} count: {snap.doubled}
</div>
<button onClick={() => ++state.count}>{name} button</button>
</>
)
}
const { getByText } = render(
<StrictMode>
<Counter name="A" />
<Counter name="B" />
</StrictMode>,
)
await waitFor(() => {
getByText('A count: 0')
getByText('B count: 0')
})
computeDouble.mockClear()
fireEvent.click(getByText('A button'))
await waitFor(() => {
getByText('A count: 2')
getByText('B count: 2')
})
expect(computeDouble).toBeCalledTimes(1)
})
it('object getters returning object', async () => {
const computeDouble = vi.fn((x: number) => x * 2)
const state = proxy({
count: 0,
get doubled() {
return { value: computeDouble(this.count) }
},
})
const Counter = ({ name }: { name: string }) => {
const snap = useSnapshot(state)
return (
<>
<div>
{name} count: {snap.doubled.value}
</div>
<button onClick={() => ++state.count}>{name} button</button>
</>
)
}
const { getByText } = render(
<StrictMode>
<Counter name="A" />
<Counter name="B" />
</StrictMode>,
)
await waitFor(() => {
getByText('A count: 0')
getByText('B count: 0')
})
computeDouble.mockClear()
fireEvent.click(getByText('A button'))
await waitFor(() => {
getByText('A count: 2')
getByText('B count: 2')
})
expect(computeDouble).toBeCalledTimes(1)
})
|
7,365 | 0 | petrpan-code/pmndrs/valtio | petrpan-code/pmndrs/valtio/tests/history.test.tsx | import { StrictMode } from 'react'
import { fireEvent, render } from '@testing-library/react'
import { it } from 'vitest'
import { useSnapshot } from 'valtio'
import { proxyWithHistory } from 'valtio/utils'
it('simple count', async () => {
const state = proxyWithHistory(0)
const Counter = () => {
const snap = useSnapshot(state)
return (
<>
<div>count: {snap.value}</div>
<button onClick={() => ++state.value}>inc</button>
<button onClick={snap.undo}>undo</button>
<button onClick={snap.redo}>redo</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('inc'))
await findByText('count: 1')
fireEvent.click(getByText('inc'))
await findByText('count: 2')
fireEvent.click(getByText('inc'))
await findByText('count: 3')
fireEvent.click(getByText('undo'))
await findByText('count: 2')
fireEvent.click(getByText('redo'))
await findByText('count: 3')
fireEvent.click(getByText('undo'))
await findByText('count: 2')
fireEvent.click(getByText('undo'))
await findByText('count: 1')
fireEvent.click(getByText('undo'))
await findByText('count: 0')
fireEvent.click(getByText('inc'))
await findByText('count: 1')
fireEvent.click(getByText('undo'))
await findByText('count: 0')
})
it('count in object', async () => {
const state = proxyWithHistory({ count: 0 })
const Counter = () => {
const snap = useSnapshot(state)
return (
<>
<div>count: {snap.value.count}</div>
<button onClick={() => ++state.value.count}>inc</button>
<button onClick={snap.undo}>undo</button>
<button onClick={snap.redo}>redo</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('inc'))
await findByText('count: 1')
fireEvent.click(getByText('inc'))
await findByText('count: 2')
fireEvent.click(getByText('inc'))
await findByText('count: 3')
fireEvent.click(getByText('undo'))
await findByText('count: 2')
fireEvent.click(getByText('redo'))
await findByText('count: 3')
fireEvent.click(getByText('undo'))
await findByText('count: 2')
fireEvent.click(getByText('undo'))
await findByText('count: 1')
fireEvent.click(getByText('undo'))
await findByText('count: 0')
fireEvent.click(getByText('inc'))
await findByText('count: 1')
fireEvent.click(getByText('undo'))
await findByText('count: 0')
})
it('count in nested object', async () => {
const state = proxyWithHistory({ nested: { count: 0 } })
const Counter = () => {
const snap = useSnapshot(state)
return (
<>
<div>count: {snap.value.nested.count}</div>
<button onClick={() => ++state.value.nested.count}>inc</button>
<button onClick={snap.undo}>undo</button>
<button onClick={snap.redo}>redo</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('inc'))
await findByText('count: 1')
fireEvent.click(getByText('inc'))
await findByText('count: 2')
fireEvent.click(getByText('inc'))
await findByText('count: 3')
fireEvent.click(getByText('undo'))
await findByText('count: 2')
fireEvent.click(getByText('redo'))
await findByText('count: 3')
fireEvent.click(getByText('undo'))
await findByText('count: 2')
fireEvent.click(getByText('undo'))
await findByText('count: 1')
fireEvent.click(getByText('undo'))
await findByText('count: 0')
fireEvent.click(getByText('inc'))
await findByText('count: 1')
fireEvent.click(getByText('undo'))
await findByText('count: 0')
})
it('multiple redos at once (#323)', async () => {
const state = proxyWithHistory({ nested: { count: 0 } })
const Counter = () => {
const snap = useSnapshot(state)
return (
<>
<div>count: {snap.value.nested.count}</div>
<button onClick={() => ++state.value.nested.count}>inc</button>
<button
onClick={() => {
state.undo()
state.undo()
}}
>
undo twice
</button>
<button
onClick={() => {
state.redo()
state.redo()
}}
>
redo twice
</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('inc'))
await findByText('count: 1')
fireEvent.click(getByText('inc'))
await findByText('count: 2')
fireEvent.click(getByText('undo twice'))
await findByText('count: 0')
fireEvent.click(getByText('redo twice'))
await findByText('count: 2')
})
it('nested array (#516)', async () => {
interface Level1Interface {
level1Values: number[]
}
interface Level0Interface {
level0Values: Level1Interface[]
}
const state = proxyWithHistory<Level0Interface>({
level0Values: [{ level1Values: [0, 1] }, { level1Values: [2, 3] }],
})
const NestedArray = () => {
const snap = useSnapshot(state)
return (
<>
<div>values: {JSON.stringify(snap.value)}</div>
<button
onClick={() => {
state.undo()
}}
>
undo
</button>
<button
onClick={() => {
if (state.value.level0Values[1]) {
state.value.level0Values[1].level1Values[0] = 10
}
}}
>
change 2 to 10
</button>
<button
onClick={() => {
if (state.value.level0Values[1]) {
state.value.level0Values[1].level1Values[0] = 11
}
}}
>
change 10 to 11
</button>
<button
onClick={() => {
if (state.value.level0Values[0]) {
state.value.level0Values[0].level1Values[0] = 12
}
}}
>
change 0 to 12
</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<NestedArray />
</StrictMode>,
)
await findByText(
'values: {"level0Values":[{"level1Values":[0,1]},{"level1Values":[2,3]}]}',
)
fireEvent.click(getByText('change 2 to 10'))
await findByText(
'values: {"level0Values":[{"level1Values":[0,1]},{"level1Values":[10,3]}]}',
)
fireEvent.click(getByText('change 10 to 11'))
await findByText(
'values: {"level0Values":[{"level1Values":[0,1]},{"level1Values":[11,3]}]}',
)
fireEvent.click(getByText('undo')) // => 11 back to 10
await findByText(
'values: {"level0Values":[{"level1Values":[0,1]},{"level1Values":[10,3]}]}',
)
fireEvent.click(getByText('change 0 to 12'))
await findByText(
'values: {"level0Values":[{"level1Values":[12,1]},{"level1Values":[10,3]}]}',
)
fireEvent.click(getByText('undo')) // => 12 back to 0
await findByText(
'values: {"level0Values":[{"level1Values":[0,1]},{"level1Values":[10,3]}]}',
)
fireEvent.click(getByText('undo')) // => 10 back to 2
await findByText(
'values: {"level0Values":[{"level1Values":[0,1]},{"level1Values":[2,3]}]}',
)
})
|
7,366 | 0 | petrpan-code/pmndrs/valtio | petrpan-code/pmndrs/valtio/tests/macro-vite.test.ts | import { EnvContext } from '@typed-macro/core'
import { createTransformer } from '@typed-macro/runtime'
import { expect, it } from 'vitest'
import { valtioMacro } from 'valtio/macro/vite'
const env: EnvContext = {
host: 'test',
packageManager: 'test',
projectPath: [''],
dev: true,
ssr: false,
}
it('basic', async () => {
const transform = createTransformer({})
transform.appendMacros('valtio/macro', [valtioMacro])
expect(
transform.transform(
`
import { useProxy } from 'valtio/macro'
const Component = () => {
useProxy(state)
return (
<div>
{state.count}
<button onClick={() => ++state.count}>inc</button>
</div>
)
}
`,
'test.ts',
env,
),
).toMatchSnapshot()
})
it('complex', async () => {
const transform = createTransformer({})
transform.appendMacros('valtio/macro', [valtioMacro])
expect(
transform.transform(
`
import { useProxy } from 'valtio/macro'
const Component = () => {
useProxy(state)
return (
<div>
<button onClick={() => {
;(() => ++state.count)()
++state.count
}}>inc</button>
{state.count}
</div>
)
}
`,
'test.ts',
env,
),
).toMatchSnapshot()
})
|
7,367 | 0 | petrpan-code/pmndrs/valtio | petrpan-code/pmndrs/valtio/tests/macro.test.ts | /* eslint-disable @typescript-eslint/ban-ts-comment */
import plugin from 'babel-plugin-macros'
import BabelPluginTester from 'babel-plugin-tester'
import { describe, expect, it } from 'vitest'
// @ts-ignore
globalThis.describe = describe
// @ts-ignore
globalThis.it = it
// @ts-ignore
globalThis.expect = expect
const pluginTester = (BabelPluginTester as any).default || BabelPluginTester
pluginTester({
pluginName: 'valtio/macro',
plugin,
snapshot: true,
babelOptions: {
filename: './valtio/tests',
parserOpts: { plugins: ['jsx'] },
},
tests: [
`
import { useProxy } from '../dist/macro'
const Component = () => {
useProxy(state)
return (
<div>
{state.count}
<button onClick={() => ++state.count}>inc</button>
</div>
)
}
`,
`
import { useProxy } from '../dist/macro'
const Component = () => {
useProxy(state)
return (
<div>
<button onClick={() => {
;(() => ++state.count)()
++state.count
}}>inc</button>
{state.count}
</div>
)
}
`,
],
})
|
7,368 | 0 | petrpan-code/pmndrs/valtio | petrpan-code/pmndrs/valtio/tests/mapset.test.tsx | import { StrictMode } from 'react'
import { fireEvent, render } from '@testing-library/react'
import { expect, it } from 'vitest'
import { proxy, useSnapshot } from 'valtio'
it('unsupported map', async () => {
const obj = proxy({ map: new Map([['count', 0]]) })
const Counter = () => {
const snap = useSnapshot(obj) as any
return (
<>
<div>count: {snap.map.get('count')}</div>
<button onClick={() => obj.map.set('count', 1)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('button'))
await new Promise((resolve) => setTimeout(resolve, 10)) // FIXME better way?
expect(() => getByText('count: 1')).toThrow()
})
it('unsupported set', async () => {
const obj = proxy({ set: new Set([1, 2, 3]) })
const Counter = () => {
const snap = useSnapshot(obj) as any
return (
<>
<div>count: {[...snap.set].join(',')}</div>
<button onClick={() => obj.set.add(4)}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 1,2,3')
fireEvent.click(getByText('button'))
await new Promise((resolve) => setTimeout(resolve, 10)) // FIXME better way?
expect(() => getByText('count: 1,2,3,4')).toThrow()
})
|
7,369 | 0 | petrpan-code/pmndrs/valtio | petrpan-code/pmndrs/valtio/tests/memoryleaks.test.ts | import { exec } from 'child_process'
import { describe, expect, it } from 'vitest'
describe('no memory leaks with proxy', () => {
const runTest = async (code: string) => {
const testCode = `
const { proxy } = require("./dist/vanilla.js");
${code}
const registry = new FinalizationRegistry(() => {
console.log("state is garbage collected");
});
registry.register(state, undefined);
state = null;
setImmediate(() => {
global.gc();
});
`
const output = await new Promise((resolve) => {
exec(`node --expose-gc --eval '${testCode}'`, (err, stdout) => {
resolve(err || stdout)
})
})
expect(output).toMatch('state is garbage collected')
}
it('empty object', async () => {
await runTest(`
let state = proxy({});
`)
})
it('child object', async () => {
await runTest(`
let state = proxy({ child: {} });
`)
})
it('global child object', async () => {
await runTest(`
const child = {};
let state = proxy({ child });
`)
})
it('global child proxy', async () => {
await runTest(`
const child = proxy({});
let state = proxy({ child });
`)
})
})
|
7,370 | 0 | petrpan-code/pmndrs/valtio | petrpan-code/pmndrs/valtio/tests/proxyMap.test.tsx | import { StrictMode } from 'react'
import { fireEvent, render, waitFor } from '@testing-library/react'
import { describe, expect, it, vi } from 'vitest'
import { proxy, useSnapshot } from 'valtio'
import { proxyMap, proxySet } from 'valtio/utils'
const initialValues = [
{
name: 'number',
value: [[-10, 1]],
},
{
name: 'string',
value: [['hello', 'world']],
},
{
name: 'Symbol',
value: [[Symbol(), Symbol()]],
},
{
name: 'boolean',
value: [[false, true]],
},
{
name: 'array',
value: [
[
[10, 'hello'],
[1, 2, 3, 'x', 'w'],
],
],
},
{
name: 'object',
value: [[{}, { id: 'something', field: null }]],
},
{
name: 'null',
value: [[null, [null, 1]]],
},
{
name: 'function',
value: [[() => {}, () => {}]],
},
{
name: 'array buffer',
value: [[new ArrayBuffer(8), new ArrayBuffer(8)]],
},
{
name: 'Set',
value: [[new Set(), new Set(['x', 'y', 'z'])]],
},
{
name: 'Map',
value: [[new Map(), new Map([['key', 'value']])]],
},
{
name: 'proxySet',
value: [[proxySet([{}]), proxySet([{}, Symbol()])]],
},
]
const inputValues = [
{
name: 'array',
value: [1, 'hello'],
},
{
name: 'nested array',
value: [[1, 'hello']],
},
{
name: 'Map',
value: new Map<any, any>([
['key1', 'value1'],
[{}, 'value2'],
]),
},
{
name: 'boolean',
value: false,
},
{
name: 'number',
value: 123,
},
{
name: 'string',
value: 'hello',
},
{
name: 'Set',
value: new Set([1, 2, 3]),
},
{
name: 'proxySet',
value: proxySet([1, {}, null, 'xyz', Symbol()]),
},
{
name: 'object',
value: { id: Symbol(), field: 'field', bool: true, null: null },
},
]
describe('features parity with native Map', () => {
initialValues.forEach(({ name, value }) => {
it(`Support Map operations on ${name}`, () => {
const map = proxyMap(value as any)
const nativeMap = new Map(value as any)
// check for Symbol.toStringTag / toString
expect(`${map}`).toBe(`${nativeMap}`)
const expectOutputToMatch = () => {
expect(map.size).toStrictEqual(nativeMap.size)
expect(Array.from(map.values())).toStrictEqual(
Array.from(nativeMap.values()),
)
expect(Array.from(map.keys())).toStrictEqual(
Array.from(nativeMap.keys()),
)
expect(Array.from(map.entries())).toStrictEqual(
Array.from(nativeMap.entries()),
)
expect(JSON.stringify(map)).toStrictEqual(JSON.stringify(nativeMap))
JSON.stringify(map, (_, mapV) => {
JSON.stringify(nativeMap, (_, nativeMapV) => {
expect(mapV).toStrictEqual(nativeMapV)
})
})
// cover loops
const handleForEach = vi.fn()
const handleForOf = vi.fn()
map.forEach(handleForEach)
expect(handleForEach).toHaveBeenCalledTimes(map.size)
for (const _ of map) {
handleForOf()
}
expect(handleForOf).toHaveBeenCalledTimes(map.size)
}
expectOutputToMatch()
const [firstElementFromMap] = map
const [firstElementFromNativeMap] = nativeMap
// Bypass Forbidden non-null assertion
const keyFromMap = firstElementFromMap && firstElementFromMap[0]
const keyFromNativeMap =
firstElementFromNativeMap && firstElementFromNativeMap[0]
expect(map.has(keyFromMap)).toBe(nativeMap.has(keyFromNativeMap))
map.delete(keyFromMap)
nativeMap.delete(keyFromNativeMap)
expectOutputToMatch()
map.set('newKey', {})
nativeMap.set('newKey', {})
expectOutputToMatch()
// test value replacement
map.set('newKey', 'newValue')
nativeMap.set('newKey', 'newValue')
expectOutputToMatch()
// test getter
expect(map.get('newKey')).toBe(nativeMap.get('newKey'))
})
})
it('support initialization with null', () => {
const map = proxyMap(null)
const nativeMap = new Map(null)
expect(map.size).toStrictEqual(nativeMap.size)
expect(Array.from(map.values())).toStrictEqual(
Array.from(nativeMap.values()),
)
expect(Array.from(map.keys())).toStrictEqual(Array.from(nativeMap.keys()))
expect(Array.from(map.entries())).toStrictEqual(
Array.from(nativeMap.entries()),
)
})
})
describe('clear map', () => {
initialValues.forEach(({ name, value }) => {
it(`clear proxyMap of ${name}`, async () => {
const state = proxyMap(value as any)
const TestComponent = () => {
const snap = useSnapshot(state)
return (
<>
<div>size: {snap.size}</div>
<button onClick={() => state.clear()}>button</button>
</>
)
}
const { getByText } = render(
<StrictMode>
<TestComponent />
</StrictMode>,
)
expect(state.size).toBeGreaterThan(0)
getByText(`size: ${state.size}`)
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('size: 0')
})
})
})
})
describe('add value', () => {
inputValues.forEach(({ name, value }) => {
it(`update size when adding ${name}`, async () => {
const state = proxy({
map: proxyMap(),
})
const TestComponent = () => {
const snap = useSnapshot(state)
return (
<>
<div>size: {snap.map.size}</div>
<button onClick={() => state.map.set(value, value)}>button</button>
</>
)
}
const { getByText } = render(
<StrictMode>
<TestComponent />
</StrictMode>,
)
getByText('size: 0')
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('size: 1')
})
})
})
})
describe('delete', () => {
inputValues.forEach(({ name, value }) => {
it(`return false when trying to delete non-existing value of type ${name}`, () => {
const set = proxyMap()
expect(set.delete(value)).toBe(false)
})
})
initialValues.forEach(({ name, value }) => {
it(`support delete on key of type ${name}`, async () => {
const state = proxy({
map: proxyMap(value as any),
})
// pick a random value from the set
const [firstValue] = state.map
// Bypass Forbidden non-null assertion
const firstKey = firstValue && firstValue[0]
const TestComponent = () => {
const snap = useSnapshot(state)
return (
<>
<div>size: {snap.map.size}</div>
<button onClick={() => state.map.delete(firstKey)}>button</button>
</>
)
}
const { getByText } = render(
<StrictMode>
<TestComponent />
</StrictMode>,
)
getByText(`size: ${state.map.size}`)
const expectedSizeAfterDelete =
state.map.size > 1 ? state.map.size - 1 : 0
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText(`size: ${expectedSizeAfterDelete}`)
})
})
})
})
describe('proxyMap internal', () => {
it('should be sealed', () => {
expect(Object.isSealed(proxySet())).toBe(true)
})
it('should list only enumerable properties', () => {
const notEnumerableProps = ['data', 'size', 'toJSON']
expect(
Object.keys(proxyMap()).some((k) => notEnumerableProps.includes(k)),
).toBe(false)
})
})
|
7,371 | 0 | petrpan-code/pmndrs/valtio | petrpan-code/pmndrs/valtio/tests/proxySet.test.tsx | import { StrictMode } from 'react'
import { fireEvent, render, waitFor } from '@testing-library/react'
import { describe, expect, it, vi } from 'vitest'
import { proxy, useSnapshot } from 'valtio'
import { proxySet } from 'valtio/utils'
// used to initialize proxySet during tests
const initialValues = [
{
name: 'array',
value: ['lorem', false, 1],
},
{
name: 'nested array',
value: [
[1, 2, 3],
[1, 2],
[51, 2, 3],
],
},
{
name: 'Map',
value: new Map([
['key1', 'value1'],
['key2', 'value2'],
]),
},
{
name: 'Set',
value: new Set([
['key1', 'value1'],
['key2', 'value2'],
]),
},
{
name: 'string value',
value: 'hello',
},
{
name: 'nested Set',
value: new Set([
new Set([1, 2, 3]),
new Set([1, 2]),
new Set(['x', 'y', 'z']),
]),
},
{
name: 'proxySet',
value: proxySet([1, {}, true]),
},
{
name: 'array of proxySet',
value: [proxySet([1, 2, 3]), proxySet([1, 2]), proxySet(['x', 'y', 'z'])],
},
{
name: 'list of objects',
value: [
{ id: Symbol(), field: 'field', bool: true, null: null },
{ id: Symbol(), field: 'field1', bool: false, null: null },
{ id: Symbol(), field: 'field3', bool: true, null: null },
],
},
]
// used to test various input types
const inputValues = [
{
name: 'array',
value: [1, 'hello'],
},
{
name: 'nested array',
value: [[1, 'hello']],
},
{
name: 'Map',
value: new Map<any, any>([
['key1', 'value1'],
[{}, 'value2'],
]),
},
{
name: 'boolean',
value: false,
},
{
name: 'number',
value: 123,
},
{
name: 'string',
value: 'hello',
},
{
name: 'Set',
value: new Set([1, 2, 3]),
},
{
name: 'proxySet',
value: proxySet([1, {}, null, 'xyz', Symbol()]),
},
{
name: 'object',
value: { id: Symbol(), field: 'field', bool: true, null: null },
},
]
describe('features parity with native Set', () => {
initialValues.forEach(({ name, value }) => {
it(`support Set operations on ${name}`, () => {
const set = proxySet<unknown>(value)
const nativeSet = new Set<unknown>(value)
// check for Symbol.toStringTag / toString
expect(`${set}`).toBe(`${nativeSet}`)
const expectOutputToMatch = () => {
expect(set.size).toStrictEqual(nativeSet.size)
expect(Array.from(set.values())).toStrictEqual(
Array.from(nativeSet.values()),
)
expect(Array.from(set.keys())).toStrictEqual(
Array.from(nativeSet.keys()),
)
expect(Array.from(set.entries())).toStrictEqual(
Array.from(nativeSet.entries()),
)
expect(JSON.stringify(set)).toStrictEqual(JSON.stringify(nativeSet))
JSON.stringify(set, (_, setV) => {
JSON.stringify(nativeSet, (_, nativeSetV) => {
expect(setV).toStrictEqual(nativeSetV)
})
})
// cover loops
const handleForEach = vi.fn()
const handleForOf = vi.fn()
set.forEach(handleForEach)
expect(handleForEach).toHaveBeenCalledTimes(set.size)
for (const _ of set) {
handleForOf()
}
expect(handleForOf).toHaveBeenCalledTimes(set.size)
}
expectOutputToMatch()
const [valueToDeleteFromSet] = set
const [valueToDeleteFromNativeSet] = nativeSet
expect(set.delete(valueToDeleteFromSet)).toBe(
nativeSet.delete(valueToDeleteFromNativeSet),
)
expectOutputToMatch()
set.add('newValue')
nativeSet.add('newValue')
expectOutputToMatch()
set.clear()
nativeSet.clear()
expectOutputToMatch()
})
})
inputValues.forEach(({ value, name }) => {
it(`prevent adding duplicate for type ${name}`, () => {
const set = proxySet<unknown>([value])
expect(set.size).toBe(1)
set.add(value)
expect(set.size).toBe(1)
})
})
})
describe('unsupported initial values', () => {
const unsupportedInputTestCases = [
{
name: 'boolean',
value: true,
},
{
name: 'number',
value: 123,
},
{
name: 'symbol',
value: Symbol(),
},
]
unsupportedInputTestCases.forEach(({ name, value }) => {
it(`throw type error when using ${name} as initial value`, () => {
expect(() => proxySet(value as any)).toThrow(/not iterable/)
})
})
})
describe('clear set', () => {
initialValues.forEach(({ name, value }) => {
it(`clear proxySet of ${name}`, async () => {
const state = proxy({
set: proxySet<unknown>(value),
})
const TestComponent = () => {
const snap = useSnapshot(state)
return (
<>
<div>size: {snap.set.size}</div>
<button onClick={() => state.set.clear()}>button</button>
</>
)
}
const { getByText } = render(
<StrictMode>
<TestComponent />
</StrictMode>,
)
getByText(`size: ${state.set.size}`)
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('size: 0')
})
})
})
})
describe('add value', () => {
inputValues.forEach(({ name, value }) => {
it(`update size when adding ${name}`, async () => {
const state = proxy({
set: proxySet(),
})
const TestComponent = () => {
const snap = useSnapshot(state)
return (
<>
<div>size: {snap.set.size}</div>
<button onClick={() => state.set.add(value)}>button</button>
</>
)
}
const { getByText } = render(
<StrictMode>
<TestComponent />
</StrictMode>,
)
getByText('size: 0')
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText('size: 1')
})
})
})
})
describe('delete', () => {
initialValues.forEach(({ name, value }) => {
it(`support delete on ${name}`, async () => {
const state = proxy({
set: proxySet<unknown>(value),
})
// pick a random value from the set
const valueToDelete = Array.from(state.set)[
Math.floor(Math.random() * state.set.size)
]
const TestComponent = () => {
const snap = useSnapshot(state)
return (
<>
<div>size: {snap.set.size}</div>
<button onClick={() => state.set.delete(valueToDelete)}>
button
</button>
</>
)
}
const { getByText } = render(
<StrictMode>
<TestComponent />
</StrictMode>,
)
getByText(`size: ${state.set.size}`)
const expectedSizeAfterDelete =
state.set.size > 1 ? state.set.size - 1 : 0
fireEvent.click(getByText('button'))
await waitFor(() => {
getByText(`size: ${expectedSizeAfterDelete}`)
})
})
})
inputValues.forEach(({ name, value }) => {
it(`return false when trying to delete non-existing value of type ${name}`, () => {
const set = proxySet()
expect(set.delete(value)).toBe(false)
})
})
})
describe('proxySet internal', () => {
it('should be sealed', () => {
expect(Object.isSealed(proxySet())).toBe(true)
})
it('should list only enumerable properties', () => {
const notEnumerableProps = ['data', 'size', 'toJSON']
expect(
Object.keys(proxySet()).some((k) => notEnumerableProps.includes(k)),
).toBe(false)
})
})
|
7,372 | 0 | petrpan-code/pmndrs/valtio | petrpan-code/pmndrs/valtio/tests/ref.test.tsx | import { StrictMode, useEffect, useRef } from 'react'
import { fireEvent, render } from '@testing-library/react'
import { expect, it, vi } from 'vitest'
import { proxy, ref, snapshot, subscribe, useSnapshot } from 'valtio'
it('should trigger re-render setting objects with ref wrapper', async () => {
const obj = proxy({ nested: ref({ count: 0 }) })
const Counter = () => {
const snap = useSnapshot(obj)
const commitsRef = useRef(1)
useEffect(() => {
commitsRef.current += 1
})
return (
<>
<div>
count: {snap.nested.count} ({commitsRef.current})
</div>
<button onClick={() => (obj.nested = ref({ count: 0 }))}>button</button>
</>
)
}
const { getByText, findByText } = render(
<>
<Counter />
</>,
)
await findByText('count: 0 (1)')
fireEvent.click(getByText('button'))
await findByText('count: 0 (2)')
})
it('should not track object wrapped in ref assigned to proxy state', async () => {
const obj = proxy<{ ui: JSX.Element | null }>({ ui: null })
const Component = () => {
const snap = useSnapshot(obj)
return (
<>
{snap.ui || <span>original</span>}
<button onClick={() => (obj.ui = ref(<span>replace</span>))}>
button
</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Component />
</StrictMode>,
)
await findByText('original')
fireEvent.click(getByText('button'))
await findByText('replace')
})
it('should not trigger re-render when mutating object wrapped in ref', async () => {
const obj = proxy({ nested: ref({ count: 0 }) })
const Counter = () => {
const snap = useSnapshot(obj)
return (
<>
<div>count: {snap.nested.count}</div>
<button onClick={() => ++obj.nested.count}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
fireEvent.click(getByText('button'))
await findByText('count: 0')
})
it('should not update snapshot or notify subscription when mutating proxy wrapped in ref', async () => {
const obj = proxy({ nested: ref(proxy({ count: 0 })) })
const snap1 = snapshot(obj)
++obj.nested.count
const snap2 = snapshot(obj)
expect(snap2).toBe(snap1)
const callback = vi.fn()
subscribe(obj, callback)
++obj.nested.count
await Promise.resolve()
expect(callback).not.toBeCalled()
})
|
7,374 | 0 | petrpan-code/pmndrs/valtio | petrpan-code/pmndrs/valtio/tests/snapshot.test.ts | import { createProxy, getUntracked } from 'proxy-compare'
import { TypeEqual, expectType } from 'ts-expect'
import { describe, expect, it } from 'vitest'
import { INTERNAL_Snapshot as Snapshot, proxy, snapshot } from 'valtio'
const sleep = (ms: number) =>
new Promise((resolve) => {
setTimeout(resolve, ms)
})
it('getter returns value after promise is resolved', async () => {
const state = proxy<any>({ status: sleep(10).then(() => 'done') })
const snap = snapshot(state)
await new Promise((resolve) => {
resolve(snap.status)
})
.catch((thrown) => {
expect(thrown).toBeInstanceOf(Promise)
return thrown
})
.then((value) => {
expect(value).toBe('done')
expect(snap.status).toBe('done')
})
})
it('should return correct snapshots without subscribe', async () => {
const child = proxy({ count: 0 })
const state = proxy({ child })
expect(snapshot(state)).toEqual({ child: { count: 0 } })
++child.count
expect(snapshot(state)).toEqual({ child: { count: 1 } })
})
it('should not change snapshot with assigning same object', async () => {
const obj = {}
const state = proxy({ obj })
const snap1 = snapshot(state)
state.obj = obj
const snap2 = snapshot(state)
expect(snap1).toBe(snap2)
})
it('should make the snapshot immutable', () => {
const state = proxy<{ foo: number; bar?: string }>({ foo: 1 })
const snap = snapshot(state)
// Overwriting existing property
expect(() => {
;(snap as typeof state).foo = 100
}).toThrow()
// Extension (adding new property)
expect(() => {
;(snap as typeof state).bar = 'hello'
}).toThrow()
// Note: The current implementation does not prevent property removal.
// Do not add a test for this unless we come up with an implementation that
// supports it.
// See https://github.com/pmndrs/valtio/issues/749
})
it('should not cause proxy-compare to copy', async () => {
const state = proxy({ foo: 1 })
const snap1 = snapshot(state)
// Ensure configurable is true, otherwise proxy-compare will copy the object
// so that its Proxy.get trap can work, and we don't want that perf overhead.
expect(Object.getOwnPropertyDescriptor(snap1, 'foo')).toEqual({
configurable: true,
enumerable: true,
value: 1,
writable: false,
})
// Technically getUntracked is smart enough to not return the copy, so this
// assertion doesn't strictly mean we avoided the copy
const cmp = createProxy(snap1, new WeakMap())
expect(getUntracked(cmp)).toBe(snap1)
})
it('should create a new proxy from a snapshot', async () => {
const state = proxy({ c: 0 })
const snap1 = snapshot(state)
const state2 = proxy(snap1)
expect(state2.c).toBe(0)
})
describe('snapsoht typings', () => {
it('converts object properties to readonly', () => {
expectType<
TypeEqual<
Snapshot<{
string: string
number: number
null: null
undefined: undefined
bool: boolean
someFunction(): number
ref: {
$$valtioRef: true
}
}>,
{
readonly string: string
readonly number: number
readonly null: null
readonly undefined: undefined
readonly bool: boolean
readonly someFunction: () => number
readonly ref: {
$$valtioRef: true
}
}
>
>(true)
})
it('infers Promise result from property value', () => {
expectType<
TypeEqual<
Snapshot<{ promise: Promise<string> }>,
{ readonly promise: string }
>
>(true)
})
it('converts arrays to readonly arrays', () => {
expectType<TypeEqual<Snapshot<number[]>, readonly number[]>>(true)
})
it('keeps builtin objects from SnapshotIgnore as-is', () => {
expectType<
TypeEqual<
Snapshot<{
date: Date
map: Map<string, unknown>
set: Set<string>
regexp: RegExp
error: Error
weakMap: WeakMap<any, any>
weakSet: WeakSet<any>
}>,
{
readonly date: Date
readonly map: Map<string, unknown>
readonly set: Set<string>
readonly regexp: RegExp
readonly error: Error
readonly weakMap: WeakMap<any, any>
readonly weakSet: WeakSet<any>
}
>
>(true)
})
it('converts collections to readonly', () => {
expectType<
TypeEqual<
Snapshot<{ key: string }[]>,
readonly { readonly key: string }[]
>
>(true)
})
it('converts object properties to readonly recursively', () => {
expectType<
TypeEqual<
Snapshot<{
prevPage: number | null
nextPage: number | null
rows: number
items: {
title: string
details: string | null
createdAt: Date
updatedAt: Date
}[]
}>,
{
readonly prevPage: number | null
readonly nextPage: number | null
readonly rows: number
readonly items: readonly {
readonly title: string
readonly details: string | null
readonly createdAt: Date
readonly updatedAt: Date
}[]
}
>
>(true)
})
it('turns class fields to readonly', () => {
class User {
firstName!: string
lastName!: string
role!: string
hasRole(role: string): boolean {
return this.role === role
}
}
const user = new User()
expectType<
TypeEqual<
Snapshot<typeof user>,
{
readonly firstName: string
readonly lastName: string
readonly role: string
readonly hasRole: (role: string) => boolean
}
>
>(true)
})
it('ignores primitive types that have been branded/tagged', () => {
const symbolTag = Symbol()
expectType<
TypeEqual<
Snapshot<{
brandedWithStringKey: string & { __brand: 'Brand' }
brandedWithSymbolKey: number & { [symbolTag]: 'Tag' }
}>,
{
readonly brandedWithStringKey: string & { __brand: 'Brand' }
readonly brandedWithSymbolKey: number & { [symbolTag]: 'Tag' }
}
>
>(true)
})
})
|
7,375 | 0 | petrpan-code/pmndrs/valtio | petrpan-code/pmndrs/valtio/tests/subscribe.test.tsx | import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { proxy, ref, subscribe } from 'valtio'
import { subscribeKey } from 'valtio/utils'
const consoleWarn = console.warn
beforeEach(() => {
console.warn = vi.fn((message: string) => {
if (message === 'Please use proxy object') {
return
}
consoleWarn(message)
})
})
afterEach(() => {
console.warn = consoleWarn
})
describe('subscribe', () => {
it('should call subscription', async () => {
const obj = proxy({ count: 0 })
const handler = vi.fn()
subscribe(obj, handler)
obj.count += 1
await Promise.resolve()
expect(handler).toBeCalledTimes(1)
})
it('should be able to unsubscribe', async () => {
const obj = proxy({ count: 0 })
const handler = vi.fn()
const unsubscribe = subscribe(obj, handler)
unsubscribe()
obj.count += 1
await Promise.resolve()
expect(handler).toBeCalledTimes(0)
})
it('should be able to unsubscribe from a subscriber', async () => {
const obj = proxy({ count: 0 })
const handler = vi.fn()
const _unsubscribeA = subscribe(obj, () => {
unsubscribeB()
})
const unsubscribeB = subscribe(obj, handler)
obj.count += 1
await Promise.resolve()
expect(handler).toBeCalledTimes(0)
})
it('should call subscription of object property', async () => {
const obj = proxy({ nested: { count: 0 } })
const handler = vi.fn()
subscribe(obj.nested, handler)
obj.nested.count += 1
await Promise.resolve()
expect(handler).toBeCalledTimes(1)
})
it('should thow if subscribing to primitive property', async () => {
const obj = proxy({ count: 0 })
const handler = vi.fn()
expect(() => subscribe(obj.count as any, handler)).toThrow()
})
it('should not re-run subscription if no change', async () => {
const obj = proxy({ count: 0 })
const handler = vi.fn()
subscribe(obj, handler)
obj.count = 0
await Promise.resolve()
expect(handler).toBeCalledTimes(0)
})
it('should not cause infinite loop', async () => {
const obj = proxy({ count: 0 })
const handler = () => {
// Reset count if above 5
if (obj.count > 5) {
obj.count = 0
}
}
subscribe(obj, handler)
obj.count = 10
})
it('should batch updates', async () => {
const obj = proxy({ count1: 0, count2: 0 })
const handler = vi.fn()
subscribe(obj, handler)
obj.count1 += 1
obj.count2 += 1
await Promise.resolve()
expect(handler).toBeCalledTimes(1)
})
it('should not call subscription for objects wrapped in ref', async () => {
const obj = proxy({ nested: ref({ count: 0 }) })
const handler = vi.fn()
subscribe(obj, handler)
obj.nested.count += 1
await Promise.resolve()
expect(handler).toBeCalledTimes(0)
})
it('should notify ops', async () => {
const obj = proxy<{ count1: number; count2?: number }>({
count1: 0,
count2: 0,
})
const handler = vi.fn()
subscribe(obj, handler)
obj.count1 += 1
obj.count2 = 2
await Promise.resolve()
expect(handler).toBeCalledTimes(1)
expect(handler).lastCalledWith([
['set', ['count1'], 1, 0],
['set', ['count2'], 2, 0],
])
delete obj.count2
await Promise.resolve()
expect(handler).toBeCalledTimes(2)
expect(handler).lastCalledWith([['delete', ['count2'], 2]])
})
it('should notify nested ops', async () => {
const obj = proxy<{ nested: { count?: number } }>({ nested: { count: 0 } })
const handler = vi.fn()
subscribe(obj, handler)
obj.nested.count = 1
await Promise.resolve()
expect(handler).toBeCalledTimes(1)
expect(handler).lastCalledWith([['set', ['nested', 'count'], 1, 0]])
delete obj.nested.count
await Promise.resolve()
expect(handler).toBeCalledTimes(2)
expect(handler).lastCalledWith([['delete', ['nested', 'count'], 1]])
})
it('should not notify with assigning same object', async () => {
const obj = {}
const state = proxy({ obj })
const handler = vi.fn()
subscribe(state, handler)
state.obj = obj
await Promise.resolve()
expect(handler).toBeCalledTimes(0)
})
})
describe('subscribeKey', () => {
it('should call subscription', async () => {
const obj = proxy({ count1: 0, count2: 0 })
const handler1 = vi.fn()
const handler2 = vi.fn()
subscribeKey(obj, 'count1', handler1)
subscribeKey(obj, 'count2', handler2)
obj.count1 += 10
await Promise.resolve()
expect(handler1).toBeCalledTimes(1)
expect(handler1).lastCalledWith(10)
expect(handler2).toBeCalledTimes(0)
obj.count2 += 20
await Promise.resolve()
expect(handler1).toBeCalledTimes(1)
expect(handler2).toBeCalledTimes(1)
expect(handler2).lastCalledWith(20)
})
})
|
7,376 | 0 | petrpan-code/pmndrs/valtio | petrpan-code/pmndrs/valtio/tests/watch.test.tsx | import { describe, expect, it, vi } from 'vitest'
import { proxy } from 'valtio'
import { watch } from 'valtio/utils'
describe('watch', () => {
it('should re-run for individual proxy updates', async () => {
const reference = proxy({ value: 'Example' })
const callback = vi.fn()
watch((get) => {
get(reference)
callback()
})
expect(callback).toBeCalledTimes(1)
reference.value = 'Update'
await Promise.resolve()
expect(callback).toBeCalledTimes(2)
})
it('should re-run for multiple proxy updates', async () => {
const A = proxy({ value: 'A' })
const B = proxy({ value: 'B' })
const callback = vi.fn()
watch((get) => {
get(A)
get(B)
callback()
})
expect(callback).toBeCalledTimes(1)
A.value = 'B'
await Promise.resolve()
expect(callback).toBeCalledTimes(2)
B.value = 'C'
await Promise.resolve()
expect(callback).toBeCalledTimes(3)
})
it('should cleanup when state updates', async () => {
const reference = proxy({ value: 'Example' })
const callback = vi.fn()
watch((get) => {
get(reference)
return () => {
callback()
}
})
expect(callback).toBeCalledTimes(0)
reference.value = 'Update'
await Promise.resolve()
expect(callback).toBeCalledTimes(1)
})
it('should cleanup when stopped', () => {
const callback = vi.fn()
const stop = watch(() => callback)
expect(callback).toBeCalledTimes(0)
stop()
expect(callback).toBeCalledTimes(1)
})
it('should cleanup internal effects when stopped', () => {
const callback = vi.fn()
const stop = watch(() => {
watch(() => {
watch(() => {
watch(() => {
watch(() => () => {
callback()
})
})
})
})
})
expect(callback).toBeCalledTimes(0)
stop()
expect(callback).toBeCalledTimes(1)
})
it('should not loop infinitely with sync (#382)', () => {
const reference = proxy({ value: 'Example' })
watch(
(get) => {
get(reference)
},
{ sync: true },
)
reference.value = 'Update'
})
})
|
7,377 | 0 | petrpan-code/pmndrs/valtio/tests | petrpan-code/pmndrs/valtio/tests/__snapshots__/macro-vite.test.ts.snap | // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
exports[`basic 1`] = `
"import { useSnapshot as _useSnapshot } from \\"valtio\\";
const Component = () => {const valtio_macro_snap_state = _useSnapshot(
state);
return (
<div>
{valtio_macro_snap_state.count}
<button onClick={() => ++state.count}>inc</button>
</div>);
};"
`;
exports[`complex 1`] = `
"import { useSnapshot as _useSnapshot } from \\"valtio\\";
const Component = () => {const valtio_macro_snap_state = _useSnapshot(
state);
return (
<div>
<button onClick={() => {
;(() => ++state.count)();
++state.count;
}}>inc</button>
{valtio_macro_snap_state.count}
</div>);
};"
`;
|
7,378 | 0 | petrpan-code/pmndrs/valtio/tests | petrpan-code/pmndrs/valtio/tests/__snapshots__/macro.test.ts.snap | // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
exports[`valtio/macro > 1. valtio/macro > 1. valtio/macro 1`] = `
"
import { useProxy } from '../dist/macro'
const Component = () => {
useProxy(state)
return (
<div>
{state.count}
<button onClick={() => ++state.count}>inc</button>
</div>
)
}
↓ ↓ ↓ ↓ ↓ ↓
import { useSnapshot as _useSnapshot } from 'valtio'
const Component = () => {
const valtio_macro_snap_state = _useSnapshot(state)
return (
<div>
{valtio_macro_snap_state.count}
<button onClick={() => ++state.count}>inc</button>
</div>
)
}
"
`;
exports[`valtio/macro > 2. valtio/macro > 2. valtio/macro 1`] = `
"
import { useProxy } from '../dist/macro'
const Component = () => {
useProxy(state)
return (
<div>
<button onClick={() => {
;(() => ++state.count)()
++state.count
}}>inc</button>
{state.count}
</div>
)
}
↓ ↓ ↓ ↓ ↓ ↓
import { useSnapshot as _useSnapshot } from 'valtio'
const Component = () => {
const valtio_macro_snap_state = _useSnapshot(state)
return (
<div>
<button
onClick={() => {
;(() => ++state.count)()
++state.count
}}
>
inc
</button>
{valtio_macro_snap_state.count}
</div>
)
}
"
`;
|
7,654 | 0 | petrpan-code/pmndrs/leva/packages/leva/src | petrpan-code/pmndrs/leva/packages/leva/src/types/public.test.ts | /* eslint-disable react-hooks/rules-of-hooks */
/**
* Type tests (run them with yarn test:types)
*/
import { expectType } from 'tsd'
import { folder } from '../helpers'
import { createPlugin } from '../plugin'
import { useControls } from '../useControls'
/**
* api
*/
expectType<{ a: number }>(useControls({ a: 3 }))
// b shouldn't be returned by useControls when transient
expectType<{ a: number }>(useControls({ a: 3, b: { value: '#fff', onChange: () => {} } }))
// b shouldn't be returned by useControls when transient
expectType<{ a: number }>(useControls({ a: 3, b: { value: '#fff', onChange: () => {}, transient: true } }))
// @ts-expect-error transient shouldn't be usable alone
expectType<{ a: number }>(useControls({ a: 3, b: { value: '#fff', transient: true } }))
// b should be returned when transient is false
expectType<{ a: number; b: string }>(useControls({ a: 3, b: { value: '#fff', onChange: () => {}, transient: false } }))
expectType<[{ a: number }, (value: { a?: number }) => void, (path: 'a') => number]>(useControls(() => ({ a: 3 })))
expectType<
[
{ a: number },
(value: { a?: number; color?: string }) => void,
<T extends 'a' | 'color'>(path: T) => { a: number; color: string }[T]
]
>(useControls(() => ({ a: 3, color: { value: '#fff', onChange: () => {} } })))
/**
* options
*/
expectType<{ a: number }>(useControls({ a: { value: 10, render: () => true, label: 'number' } }))
expectType<{ a: { x: number; y: number } }>(
useControls({ a: { value: { x: 10, y: 10 }, label: 'label', render: (get) => get('something') } })
)
// TODO fix this as this is valid logic
// @ts-expect-error
expectType<{ a: { x: number; y: number } }>(useControls({ a: { x: 10, y: 10, label: 'label' } }))
/**
* numbers
*/
expectType<{ a: number }>(useControls({ a: 10 }))
expectType<{ a: number; b: number }>(useControls({ a: 10, b: 3 }))
expectType<{ a: number }>(useControls({ a: { value: 10 } }))
expectType<{ a: number }>(useControls({ a: { value: 10, min: 0, max: 10, step: 1 } }))
/**
* strings
*/
expectType<{ a: string }>(useControls({ a: 'some string' }))
/**
* selects
*/
expectType<{ a: string }>(useControls({ a: { options: ['foo', 'bar'] } }))
expectType<{ a: number | string }>(useControls({ a: { options: [1, 'bar'] } }))
expectType<{ a: string | number | Array<string | number> }>(useControls({ a: { options: ['foo', 1, ['foo', 'bar']] } }))
expectType<{ a: boolean | number }>(useControls({ a: { options: { foo: 1, bar: true } } }))
expectType<{ a: number | string | string[] }>(useControls({ a: { value: 3, options: ['foo', ['foo', 'bar']] } }))
/**
* images
*/
expectType<{ a: string | undefined }>(useControls({ a: { image: undefined } }))
/**
* color objects
* @note: colors represented as strings are already covered by string.
*/
expectType<{ a: { r: number; g: number; b: number } }>(useControls({ a: { r: 10, g: 10, b: 10 } }))
expectType<{ a: { r: number; g: number; b: number; a: number } }>(useControls({ a: { r: 10, g: 10, b: 10, a: 1 } }))
/**
* booleans
*/
expectType<{ a: boolean }>(useControls({ a: true }))
expectType<{ a: boolean }>(useControls({ a: false }))
/**
* intervals
*/
expectType<{ a: [number, number] }>(useControls({ a: { value: [0, 10], min: 0, max: 20 } }))
/**
* Vector2d
*/
// object format
expectType<{ a: { x: number; y: number } }>(useControls({ a: { x: 10, y: 10 } }))
expectType<{ a: { width: number; height: number } }>(useControls({ a: { width: 10, height: 10 } }))
expectType<{ a: { width: number; height: number } }>(useControls({ a: { value: { width: 10, height: 10 }, min: 0 } }))
// array format
expectType<{ a: [number, number] }>(useControls({ a: [0, 0] }))
expectType<{ a: [number, number] }>(useControls({ a: { value: [0, 0] } }))
expectType<{ a: [number, number] }>(useControls({ a: { value: [0, 0], joystick: 'invertY' } }))
/**
* Vector3d
*/
// object format
expectType<{ a: { x: number; y: number; z: number } }>(useControls({ a: { x: 10, y: 10, z: 10 } }))
expectType<{ a: { width: number; height: number; depth: number } }>(
useControls({ a: { width: 10, height: 10, depth: 1 } })
)
expectType<{ a: { width: number; height: number; depth: number } }>(
useControls({ a: { value: { width: 10, height: 10, depth: 1 } } })
)
// array format
expectType<{ a: [number, number, number] }>(useControls({ a: [0, 0, 0] }))
expectType<{ a: [number, number, number] }>(useControls({ a: { value: [0, 0, 0] } }))
/**
* folders
*/
expectType<{ a1: number; b1: number; b2: string }>(
useControls({
a: folder({
a1: 1,
b: folder({ b1: { value: 10 }, b2: 'hello' }),
}),
})
)
expectType<{
pos2dArr: [number, number]
pos3dArr: [number, number, number]
}>(
useControls({
someFolder: folder({ pos2dArr: [100, 200], innerFolder: folder({ pos3dArr: [0, 0, 0] }) }),
})
)
/**
* custom plugins
*/
const nullOrString = createPlugin({
normalize: (input: string | null) => ({ value: input }),
component: () => null,
})
const data_nullOrString = useControls({
null: nullOrString(null),
string: nullOrString('hello'),
})
expectType<{
null: null | string
string: null | string
}>(data_nullOrString)
const nullOrStringObject = createPlugin({
normalize: (input: { value: string | null }) => ({ value: input.value }),
component: () => null,
})
const data_nullOrStringObject = useControls({
null: nullOrStringObject({ value: null }),
string: nullOrStringObject({ value: 'hello' }),
})
expectType<{
null: null | string
string: null | string
}>(data_nullOrStringObject)
const arrayNumber = createPlugin({
normalize: (input: number[]) => ({ value: input }),
component: () => null,
})
const data_nullOrNumberArray = useControls({
array: arrayNumber([1, 2, 3]),
})
expectType<{ array: number[] }>(data_nullOrNumberArray)
|
8,421 | 0 | petrpan-code/shadcn-ui/ui/packages/cli/test | petrpan-code/shadcn-ui/ui/packages/cli/test/commands/init.test.ts | import fs from "fs"
import path from "path"
import { execa } from "execa"
import { afterEach, expect, test, vi } from "vitest"
import { runInit } from "../../src/commands/init"
import { getConfig } from "../../src/utils/get-config"
import * as getPackageManger from "../../src/utils/get-package-manager"
import * as registry from "../../src/utils/registry"
vi.mock("execa")
vi.mock("fs/promises", () => ({
writeFile: vi.fn(),
mkdir: vi.fn(),
}))
vi.mock("ora")
test("init config-full", async () => {
vi.spyOn(getPackageManger, "getPackageManager").mockResolvedValue("pnpm")
vi.spyOn(registry, "getRegistryBaseColor").mockResolvedValue({
inlineColors: {},
cssVars: {},
inlineColorsTemplate:
"@tailwind base;\n@tailwind components;\n@tailwind utilities;\n",
cssVarsTemplate:
"@tailwind base;\n@tailwind components;\n@tailwind utilities;\n",
})
const mockMkdir = vi.spyOn(fs.promises, "mkdir").mockResolvedValue(undefined)
const mockWriteFile = vi.spyOn(fs.promises, "writeFile").mockResolvedValue()
const targetDir = path.resolve(__dirname, "../fixtures/config-full")
const config = await getConfig(targetDir)
await runInit(targetDir, config)
expect(mockMkdir).toHaveBeenNthCalledWith(
1,
expect.stringMatching(/src\/app$/),
expect.anything()
)
expect(mockMkdir).toHaveBeenNthCalledWith(
2,
expect.stringMatching(/src\/lib$/),
expect.anything()
)
expect(mockMkdir).toHaveBeenNthCalledWith(
3,
expect.stringMatching(/src\/components$/),
expect.anything()
)
expect(mockWriteFile).toHaveBeenNthCalledWith(
1,
expect.stringMatching(/tailwind.config.ts$/),
expect.stringContaining(`import type { Config } from "tailwindcss"`),
"utf8"
)
expect(mockWriteFile).toHaveBeenNthCalledWith(
2,
expect.stringMatching(/src\/app\/globals.css$/),
expect.stringContaining(`@tailwind base`),
"utf8"
)
expect(mockWriteFile).toHaveBeenNthCalledWith(
3,
expect.stringMatching(/src\/lib\/utils.ts$/),
expect.stringContaining(`import { type ClassValue, clsx } from "clsx"`),
"utf8"
)
expect(execa).toHaveBeenCalledWith(
"pnpm",
[
"add",
"tailwindcss-animate",
"class-variance-authority",
"clsx",
"tailwind-merge",
"@radix-ui/react-icons",
],
{
cwd: targetDir,
}
)
mockMkdir.mockRestore()
mockWriteFile.mockRestore()
})
test("init config-partial", async () => {
vi.spyOn(getPackageManger, "getPackageManager").mockResolvedValue("npm")
vi.spyOn(registry, "getRegistryBaseColor").mockResolvedValue({
inlineColors: {},
cssVars: {},
inlineColorsTemplate:
"@tailwind base;\n@tailwind components;\n@tailwind utilities;\n",
cssVarsTemplate:
"@tailwind base;\n@tailwind components;\n@tailwind utilities;\n",
})
const mockMkdir = vi.spyOn(fs.promises, "mkdir").mockResolvedValue(undefined)
const mockWriteFile = vi.spyOn(fs.promises, "writeFile").mockResolvedValue()
const targetDir = path.resolve(__dirname, "../fixtures/config-partial")
const config = await getConfig(targetDir)
await runInit(targetDir, config)
expect(mockMkdir).toHaveBeenNthCalledWith(
1,
expect.stringMatching(/src\/assets\/css$/),
expect.anything()
)
expect(mockMkdir).toHaveBeenNthCalledWith(
2,
expect.stringMatching(/lib$/),
expect.anything()
)
expect(mockMkdir).toHaveBeenNthCalledWith(
3,
expect.stringMatching(/components$/),
expect.anything()
)
expect(mockWriteFile).toHaveBeenNthCalledWith(
1,
expect.stringMatching(/tailwind.config.ts$/),
expect.stringContaining(`import type { Config } from "tailwindcss"`),
"utf8"
)
expect(mockWriteFile).toHaveBeenNthCalledWith(
2,
expect.stringMatching(/src\/assets\/css\/tailwind.css$/),
expect.stringContaining(`@tailwind base`),
"utf8"
)
expect(mockWriteFile).toHaveBeenNthCalledWith(
3,
expect.stringMatching(/utils.ts$/),
expect.stringContaining(`import { type ClassValue, clsx } from "clsx"`),
"utf8"
)
expect(execa).toHaveBeenCalledWith(
"npm",
[
"install",
"tailwindcss-animate",
"class-variance-authority",
"clsx",
"tailwind-merge",
"lucide-react",
],
{
cwd: targetDir,
}
)
mockMkdir.mockRestore()
mockWriteFile.mockRestore()
})
afterEach(() => {
vi.resetAllMocks()
})
|
8,473 | 0 | petrpan-code/shadcn-ui/ui/packages/cli/test | petrpan-code/shadcn-ui/ui/packages/cli/test/utils/apply-color-mapping.test.ts | import { describe, expect, test } from "vitest"
import {
applyColorMapping,
splitClassName,
} from "../../src/utils/transformers/transform-css-vars"
import baseColor from "../fixtures/colors/slate.json"
describe("split className", () => {
test.each([
{
input: "bg-popover",
output: [null, "bg-popover", null],
},
{
input: "bg-popover/50",
output: [null, "bg-popover", "50"],
},
{
input: "hover:bg-popover/50",
output: ["hover", "bg-popover", "50"],
},
{
input: "hover:bg-popover",
output: ["hover", "bg-popover", null],
},
{
input: "[&_[cmdk-group-heading]]:px-2",
output: ["[&_[cmdk-group-heading]]", "px-2", null],
},
{
input: "[&_[cmdk-group]:not([hidden])_~[cmdk-group]]:pt-0",
output: ["[&_[cmdk-group]:not([hidden])_~[cmdk-group]]", "pt-0", null],
},
{
input: "[&_[cmdk-group]:not([hidden])_~[cmdk-group]]:bg-red-200",
output: [
"[&_[cmdk-group]:not([hidden])_~[cmdk-group]]",
"bg-red-200",
null,
],
},
{
input: "sm:focus:text-accent-foreground/30",
output: ["sm:focus", "text-accent-foreground", "30"],
},
])(`splitClassName($input) -> $output`, ({ input, output }) => {
expect(splitClassName(input)).toStrictEqual(output)
})
})
describe("apply color mapping", async () => {
test.each([
{
input: "bg-background text-foreground",
output: "bg-white text-slate-950 dark:bg-slate-950 dark:text-slate-50",
},
{
input: "rounded-lg border bg-card text-card-foreground shadow-sm",
output:
"rounded-lg border border-slate-200 bg-white text-slate-950 shadow-sm dark:border-slate-800 dark:bg-slate-950 dark:text-slate-50",
},
{
input:
"text-destructive border-destructive/50 dark:border-destructive [&>svg]:text-destructive text-destructive",
output:
"text-red-500 border-red-500/50 dark:border-red-500 [&>svg]:text-red-500 dark:text-red-900 dark:border-red-900/50 dark:dark:border-red-900 dark:[&>svg]:text-red-900",
},
{
input:
"flex h-full w-full items-center justify-center rounded-full bg-muted",
output:
"flex h-full w-full items-center justify-center rounded-full bg-slate-100 dark:bg-slate-800",
},
{
input:
"absolute right-4 top-4 bg-primary rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-secondary",
output:
"absolute right-4 top-4 bg-slate-900 rounded-sm opacity-70 ring-offset-white transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-slate-400 focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-slate-100 dark:bg-slate-50 dark:ring-offset-slate-950 dark:focus:ring-slate-800 dark:data-[state=open]:bg-slate-800",
},
])(`applyColorMapping($input) -> $output`, ({ input, output }) => {
expect(applyColorMapping(input, baseColor.inlineColors)).toBe(output)
})
})
|
8,474 | 0 | petrpan-code/shadcn-ui/ui/packages/cli/test | petrpan-code/shadcn-ui/ui/packages/cli/test/utils/get-config.test.ts | import path from "path"
import { expect, test } from "vitest"
import { getConfig, getRawConfig } from "../../src/utils/get-config"
test("get raw config", async () => {
expect(
await getRawConfig(path.resolve(__dirname, "../fixtures/config-none"))
).toEqual(null)
expect(
await getRawConfig(path.resolve(__dirname, "../fixtures/config-partial"))
).toEqual({
style: "default",
tailwind: {
config: "./tailwind.config.ts",
css: "./src/assets/css/tailwind.css",
baseColor: "neutral",
cssVariables: false,
},
rsc: false,
tsx: true,
aliases: {
components: "@/components",
utils: "@/lib/utils",
},
})
expect(
getRawConfig(path.resolve(__dirname, "../fixtures/config-invalid"))
).rejects.toThrowError()
})
test("get config", async () => {
expect(
await getConfig(path.resolve(__dirname, "../fixtures/config-none"))
).toEqual(null)
expect(
getConfig(path.resolve(__dirname, "../fixtures/config-invalid"))
).rejects.toThrowError()
expect(
await getConfig(path.resolve(__dirname, "../fixtures/config-partial"))
).toEqual({
style: "default",
tailwind: {
config: "./tailwind.config.ts",
css: "./src/assets/css/tailwind.css",
baseColor: "neutral",
cssVariables: false,
},
rsc: false,
tsx: true,
aliases: {
components: "@/components",
utils: "@/lib/utils",
},
resolvedPaths: {
tailwindConfig: path.resolve(
__dirname,
"../fixtures/config-partial",
"tailwind.config.ts"
),
tailwindCss: path.resolve(
__dirname,
"../fixtures/config-partial",
"./src/assets/css/tailwind.css"
),
components: path.resolve(
__dirname,
"../fixtures/config-partial",
"./components"
),
utils: path.resolve(
__dirname,
"../fixtures/config-partial",
"./lib/utils"
),
},
})
expect(
await getConfig(path.resolve(__dirname, "../fixtures/config-full"))
).toEqual({
style: "new-york",
rsc: false,
tsx: true,
tailwind: {
config: "tailwind.config.ts",
baseColor: "zinc",
css: "src/app/globals.css",
cssVariables: true,
},
aliases: {
components: "~/components",
utils: "~/lib/utils",
},
resolvedPaths: {
tailwindConfig: path.resolve(
__dirname,
"../fixtures/config-full",
"tailwind.config.ts"
),
tailwindCss: path.resolve(
__dirname,
"../fixtures/config-full",
"./src/app/globals.css"
),
components: path.resolve(
__dirname,
"../fixtures/config-full",
"./src/components"
),
utils: path.resolve(
__dirname,
"../fixtures/config-full",
"./src/lib/utils"
),
},
})
expect(
await getConfig(path.resolve(__dirname, "../fixtures/config-jsx"))
).toEqual({
style: "default",
tailwind: {
config: "./tailwind.config.js",
css: "./src/assets/css/tailwind.css",
baseColor: "neutral",
cssVariables: false,
},
rsc: false,
tsx: false,
aliases: {
components: "@/components",
utils: "@/lib/utils",
},
resolvedPaths: {
tailwindConfig: path.resolve(
__dirname,
"../fixtures/config-jsx",
"tailwind.config.js"
),
tailwindCss: path.resolve(
__dirname,
"../fixtures/config-jsx",
"./src/assets/css/tailwind.css"
),
components: path.resolve(
__dirname,
"../fixtures/config-jsx",
"./components"
),
utils: path.resolve(__dirname, "../fixtures/config-jsx", "./lib/utils"),
},
})
})
|
8,475 | 0 | petrpan-code/shadcn-ui/ui/packages/cli/test | petrpan-code/shadcn-ui/ui/packages/cli/test/utils/get-package-manager.test.ts | import path from "path"
import { expect, test } from "vitest"
import { getPackageManager } from "../../src/utils/get-package-manager"
test("get package manager", async () => {
expect(
await getPackageManager(path.resolve(__dirname, "../fixtures/project-yarn"))
).toBe("yarn")
expect(
await getPackageManager(path.resolve(__dirname, "../fixtures/project-npm"))
).toBe("npm")
expect(
await getPackageManager(path.resolve(__dirname, "../fixtures/project-pnpm"))
).toBe("pnpm")
expect(
await getPackageManager(path.resolve(__dirname, "../fixtures/project-bun"))
).toBe("bun")
expect(
await getPackageManager(path.resolve(__dirname, "../fixtures/next"))
).toBe("pnpm")
})
|
8,476 | 0 | petrpan-code/shadcn-ui/ui/packages/cli/test | petrpan-code/shadcn-ui/ui/packages/cli/test/utils/registry.test.ts | import { expect, test } from "vitest"
import { resolveTree } from "../../src/utils/registry"
test("resolve tree", async () => {
const index = [
{
name: "button",
dependencies: ["@radix-ui/react-slot"],
type: "components:ui",
files: ["button.tsx"],
},
{
name: "dialog",
dependencies: ["@radix-ui/react-dialog"],
registryDependencies: ["button"],
type: "components:ui",
files: ["dialog.tsx"],
},
{
name: "input",
registryDependencies: ["button"],
type: "components:ui",
files: ["input.tsx"],
},
{
name: "alert-dialog",
dependencies: ["@radix-ui/react-alert-dialog"],
registryDependencies: ["button", "dialog"],
type: "components:ui",
files: ["alert-dialog.tsx"],
},
{
name: "example-card",
type: "components:component",
files: ["example-card.tsx"],
registryDependencies: ["button", "dialog", "input"],
},
]
expect(
(await resolveTree(index, ["button"])).map((entry) => entry.name).sort()
).toEqual(["button"])
expect(
(await resolveTree(index, ["dialog"])).map((entry) => entry.name).sort()
).toEqual(["button", "dialog"])
expect(
(await resolveTree(index, ["alert-dialog", "dialog"]))
.map((entry) => entry.name)
.sort()
).toEqual(["alert-dialog", "button", "dialog"])
expect(
(await resolveTree(index, ["example-card"]))
.map((entry) => entry.name)
.sort()
).toEqual(["button", "dialog", "example-card", "input"])
expect(
(await resolveTree(index, ["foo"])).map((entry) => entry.name).sort()
).toEqual([])
expect(
(await resolveTree(index, ["button", "foo"]))
.map((entry) => entry.name)
.sort()
).toEqual(["button"])
})
|
8,477 | 0 | petrpan-code/shadcn-ui/ui/packages/cli/test | petrpan-code/shadcn-ui/ui/packages/cli/test/utils/resolve-import.test.ts | import path from "path"
import { loadConfig, type ConfigLoaderSuccessResult } from "tsconfig-paths"
import { expect, test } from "vitest"
import { resolveImport } from "../../src/utils/resolve-import"
test("resolve import", async () => {
expect(
await resolveImport("@/foo/bar", {
absoluteBaseUrl: "/Users/shadcn/Projects/foobar",
paths: {
"@/*": ["./src/*"],
"~/components/*": ["./src/components/*"],
"~/lib": ["./src/lib"],
},
})
).toEqual("/Users/shadcn/Projects/foobar/src/foo/bar")
expect(
await resolveImport("~/components/foo/bar/baz", {
absoluteBaseUrl: "/Users/shadcn/Projects/foobar",
paths: {
"@/*": ["./src/*"],
"~/components/*": ["./src/components/*"],
"~/lib": ["./src/lib"],
},
})
).toEqual("/Users/shadcn/Projects/foobar/src/components/foo/bar/baz")
expect(
await resolveImport("components/foo/bar", {
absoluteBaseUrl: "/Users/shadcn/Projects/foobar",
paths: {
"components/*": ["./src/app/components/*"],
"ui/*": ["./src/ui/primities/*"],
lib: ["./lib"],
},
})
).toEqual("/Users/shadcn/Projects/foobar/src/app/components/foo/bar")
expect(
await resolveImport("lib/utils", {
absoluteBaseUrl: "/Users/shadcn/Projects/foobar",
paths: {
"components/*": ["./src/app/components/*"],
"ui/*": ["./src/ui/primities/*"],
lib: ["./lib"],
},
})
).toEqual("/Users/shadcn/Projects/foobar/lib/utils")
})
test("resolve import with base url", async () => {
const cwd = path.resolve(__dirname, "../fixtures/with-base-url")
const config = (await loadConfig(cwd)) as ConfigLoaderSuccessResult
expect(await resolveImport("@/components/ui", config)).toEqual(
path.resolve(cwd, "components/ui")
)
expect(await resolveImport("@/lib/utils", config)).toEqual(
path.resolve(cwd, "lib/utils")
)
expect(await resolveImport("foo/bar", config)).toEqual(
path.resolve(cwd, "foo/bar")
)
})
test("resolve import without base url", async () => {
const cwd = path.resolve(__dirname, "../fixtures/without-base-url")
const config = (await loadConfig(cwd)) as ConfigLoaderSuccessResult
expect(await resolveImport("~/components/ui", config)).toEqual(
path.resolve(cwd, "components/ui")
)
expect(await resolveImport("~/lib/utils", config)).toEqual(
path.resolve(cwd, "lib/utils")
)
expect(await resolveImport("foo/bar", config)).toEqual(
path.resolve(cwd, "foo/bar")
)
})
|
Subsets and Splits