muya 2.0.0-beta.2 → 2.0.0

package/packages/core/__tests__/create-async.test.ts

@@ -1,88 +0,0 @@
-import { create } from '../create'
-import { waitFor } from '@testing-library/react'
-import { longPromise } from './test-utils'
-import { isPromise } from '../utils/is'
-import { subscriber } from '../subscriber'
-
-describe('create', () => {
-  it('should subscribe to context and notified it with parameters', async () => {
-    const state1 = create(1)
-    const state2 = create(2)
-
-    function derivedNested() {
-      return state1() + state2()
-    }
-    async function derived(plus: number) {
-      return state1() + state2() + derivedNested() + plus
-    }
-
-    let updatesCounter = 0
-    const sub = subscriber(() => derived(10))
-    expect(isPromise(sub.emitter.getSnapshot())).toBe(true)
-    sub.listen(async () => {
-      updatesCounter++
-    })
-    expect(updatesCounter).toBe(0)
-    // check if there is not maximum call stack
-    expect(await sub()).toBe(16)
-
-    state1.set(2)
-    //
-    await waitFor(async () => {})
-    expect(await sub()).toBe(18)
-
-    expect(updatesCounter).toBe(4)
-  })
-
-  it('should async subscribe to context and notified it', async () => {
-    const state1 = create(1)
-    const state2 = create(Promise.resolve(2))
-
-    async function derivedNested() {
-      await longPromise()
-      return state1() + (await state2())
-    }
-    async function derived() {
-      return state1() + (await state2()) + (await derivedNested())
-    }
-
-    let updatesCounter = 0
-
-    const sub = subscriber(derived)
-
-    sub.listen(() => {
-      updatesCounter++
-    })
-
-    // check if there is not maximum call stack
-    sub()
-
-    // check if not assigned multiple times, but only once
-    expect(state1.emitter.getSize()).toBe(1)
-    expect(state2.emitter.getSize()).toBe(1)
-    expect(sub.emitter.getSize()).toBe(1)
-    state1.set(2)
-
-    await waitFor(async () => {
-      expect(await sub()).toBe(8)
-      expect(updatesCounter).toBe(5)
-    })
-
-    state2.set(3)
-
-    await waitFor(async () => {
-      expect(await sub()).toBe(10)
-      expect(updatesCounter).toBe(10)
-    })
-
-    expect(state1.emitter.getSize()).toBe(1)
-    expect(state2.emitter.getSize()).toBe(1)
-    expect(sub.emitter.getSize()).toBe(1)
-
-    sub.destroy()
-
-    expect(state1.emitter.getSize()).toBe(0)
-    expect(state2.emitter.getSize()).toBe(0)
-    expect(sub.emitter.getSize()).toBe(0)
-  })
-})

package/packages/core/__tests__/create.test.tsx

@@ -1,107 +0,0 @@
-import { create } from '../create'
-import { waitFor } from '@testing-library/react'
-import { subscriber } from '../subscriber'
-
-describe('create', () => {
-  it('should get basic value states', async () => {
-    const state1 = create(1)
-    const state2 = create(2)
-    expect(state1()).toBe(1)
-    expect(state2()).toBe(2)
-
-    state1.set(2)
-    state2.set(3)
-
-    await waitFor(() => {
-      expect(state1()).toBe(2)
-      expect(state2()).toBe(3)
-    })
-  })
-  it('should get basic and derived value', async () => {
-    const state1 = create(1)
-    const state2 = create(2)
-
-    function derived1() {
-      return state1() + state2()
-    }
-
-    expect(state1()).toBe(1)
-    expect(state2()).toBe(2)
-    expect(derived1()).toBe(3)
-
-    state1.set(2)
-    state2.set(3)
-
-    await waitFor(() => {
-      expect(state1()).toBe(2)
-      expect(state2()).toBe(3)
-      expect(derived1()).toBe(5)
-    })
-  })
-  it('should subscribe to context and notified it', async () => {
-    const state1 = create(1)
-    const state2 = create(2)
-
-    function derivedNested() {
-      return state1() + state2()
-    }
-    function derived() {
-      return state1() + state2() + derivedNested()
-    }
-
-    let updatesCounter = 0
-
-    const sub = subscriber(derived)
-
-    sub.listen(() => {
-      updatesCounter++
-    })
-
-    // check if there is not maximum call stack
-    sub()
-    sub()
-    sub()
-
-    // check if not assigned multiple times, but only once
-    expect(state1.emitter.getSize()).toBe(1)
-    expect(state2.emitter.getSize()).toBe(1)
-    expect(sub.emitter.getSize()).toBe(1)
-    expect(sub.emitter.getSnapshot()).toBe(6)
-    state1.set(2)
-
-    await waitFor(() => {
-      expect(sub()).toBe(8)
-      expect(updatesCounter).toBe(1)
-    })
-
-    state2.set(3)
-
-    await waitFor(() => {
-      expect(sub()).toBe(10)
-      expect(updatesCounter).toBe(2)
-    })
-
-    expect(state1.emitter.getSize()).toBe(1)
-    expect(state2.emitter.getSize()).toBe(1)
-    expect(sub.emitter.getSize()).toBe(1)
-    expect(sub.emitter.getSnapshot()).toBe(10)
-
-    sub.destroy()
-
-    expect(state1.emitter.getSize()).toBe(0)
-    expect(state2.emitter.getSize()).toBe(0)
-    expect(sub.emitter.getSize()).toBe(0)
-  })
-  it('should subscribe and set snapshot', async () => {
-    const state = create(1)
-    const sub = subscriber(state)
-    sub()
-
-    expect(sub.emitter.getSnapshot()).toBe(1)
-
-    state.set(2)
-    await waitFor(() => {
-      expect(sub.emitter.getSnapshot()).toBe(2)
-    })
-  })
-})

package/packages/core/__tests__/subscriber.test.tsx

@@ -1,89 +0,0 @@
-import { waitFor } from '@testing-library/react'
-import { create } from '../create'
-import { subscriber } from '../subscriber'
-import { longPromise } from './test-utils'
-
-describe('subscriber', () => {
-  it('should test subscriber and cleaning the emitters', () => {
-    const state1 = create(1)
-    const sub = subscriber(state1)
-    // at this point, the emitter is not subscribed yet, as it need to be called first.
-    expect(state1.emitter.getSize()).toBe(0)
-
-    // check if the value is correct
-    expect(sub()).toBe(1)
-
-    // now we can check if the value is subscribed
-    expect(state1.emitter.getSize()).toBe(1)
-    // we destroy the subscriber, meaning that the emitter should be cleaned
-
-    sub.destroy()
-
-    expect(state1.emitter.getSize()).toBe(0)
-
-    // and test re-aligning the subscriber
-    expect(sub()).toBe(1)
-    expect(state1.emitter.getSize()).toBe(1)
-  })
-  it('should test how many events are emitter via singleton state', async () => {
-    const state1 = create(1)
-    const sub = subscriber(state1)
-
-    let updateCount = 0
-
-    sub.listen(() => {
-      updateCount++
-    })
-    sub()
-    await waitFor(() => {})
-    // we do not received initial value as it is not changed
-    expect(updateCount).toBe(0)
-
-    state1.set(2)
-    await waitFor(() => {})
-    expect(updateCount).toBe(1)
-  })
-  it('should test how many events are emitter via singleton async state', async () => {
-    const state1 = create(longPromise())
-    const sub = subscriber(state1)
-
-    let updateCount = 0
-
-    sub.listen(() => {
-      updateCount++
-    })
-    sub()
-    await waitFor(() => {})
-    // we do not received initial value as it is not changed
-    expect(updateCount).toBe(0)
-
-    state1.set(2)
-    await waitFor(() => {})
-    expect(updateCount).toBe(1)
-  })
-
-  it('should test how many events are emitter via derived state', async () => {
-    const state1 = create(longPromise())
-
-    async function derived() {
-      //   await longPromise()
-      return await state1()
-    }
-    const sub = subscriber(derived)
-
-    let updateCount = 0
-
-    sub.listen(() => {
-      updateCount++
-    })
-    await sub()
-    await waitFor(() => {})
-    expect(await sub()).toBe(0)
-    // // we do not received initial value as it is not changed
-    expect(updateCount).toBe(2)
-
-    // state1.set(2)
-    // await waitFor(() => {})
-    // expect(updateCount).toBe(1)
-  })
-})

package/packages/core/__tests__/use-async.test.tsx

@@ -1,45 +0,0 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-import { renderHook } from '@testing-library/react-hooks'
-import { create } from '../create'
-import { use } from '../use'
-import { Suspense } from 'react'
-import { waitFor } from '@testing-library/react'
-
-describe('use-create', () => {
-  const reRendersBefore = jest.fn()
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  it('should test sub hook', async () => {
-    const userState = create({ name: 'John', age: 30 })
-    async function getDataWithUser() {
-      const result = await fetch('https://jsonplaceholder.typicode.com/todos/1')
-      const json = await result.json()
-      return { age: userState().age, ...json }
-    }
-
-    const suspenseFunction = jest.fn()
-    function Loading() {
-      suspenseFunction()
-      return <div>Loading...</div>
-    }
-
-    const { result } = renderHook(
-      () => {
-        reRendersBefore()
-        const data = use(getDataWithUser)
-        return data
-      },
-      // @ts-expect-error
-      { wrapper: ({ children }) => <Suspense fallback={<Loading />}>{children}</Suspense> },
-    )
-
-    await waitFor(() => {
-      expect(result.current).toEqual({ userId: 1, id: 1, title: 'delectus aut autem', completed: false, age: 30 })
-    })
-    expect(suspenseFunction).toHaveBeenCalledTimes(1)
-    expect(result.current).toEqual({ userId: 1, id: 1, title: 'delectus aut autem', completed: false, age: 30 })
-  })
-})

package/packages/core/__tests__/use.test.tsx

@@ -1,125 +0,0 @@
-import { act, renderHook } from '@testing-library/react-hooks'
-import { create } from '../create'
-import { use } from '../use'
-import { waitFor } from '@testing-library/react'
-import { useCallback } from 'react'
-import { getDebugCacheCreation } from '../utils/sub-memo'
-
-describe('use-create', () => {
-  const reRendersBefore = jest.fn()
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  it('should test use hook', async () => {
-    const state = create(1)
-
-    const { result } = renderHook(() => {
-      reRendersBefore()
-      return use(state)
-    })
-
-    state.set(2)
-
-    await waitFor(() => {})
-    expect(result.current).toBe(2)
-    expect(reRendersBefore).toHaveBeenCalledTimes(2)
-
-    state.set(3)
-
-    await waitFor(() => {})
-    expect(result.current).toBe(3)
-    expect(reRendersBefore).toHaveBeenCalledTimes(3)
-  })
-
-  it('should test derived state with multiple states', async () => {
-    const state1 = create(1)
-    const state2 = create(2)
-
-    function derivedBefore(plusValue: number) {
-      return state1() + state2() + plusValue
-    }
-
-    function derived() {
-      return state1() + state2() + derivedBefore(10)
-    }
-
-    const { result } = renderHook(() => {
-      reRendersBefore()
-      return use(derived)
-    })
-
-    await waitFor(() => {})
-    expect(reRendersBefore).toHaveBeenCalledTimes(1)
-    act(() => {
-      state1.set(2)
-      state2.set(3)
-    })
-
-    await waitFor(() => {})
-    expect(result.current).toBe(20)
-    expect(reRendersBefore).toHaveBeenCalledTimes(2)
-  })
-
-  it('should test use hook without memoize fn', async () => {
-    const state1 = create(1)
-    const state2 = create(2)
-
-    function derivedBefore(plusValue: number) {
-      return state1() + state2() + plusValue
-    }
-
-    function derived(add: number) {
-      return state1() + state2() + derivedBefore(add)
-    }
-
-    const { result } = renderHook(() => {
-      reRendersBefore()
-      return use(() => derived(10))
-    })
-    expect(getDebugCacheCreation()).toBe(1)
-
-    await waitFor(() => {})
-    expect(reRendersBefore).toHaveBeenCalledTimes(1)
-    act(() => {
-      state1.set(2)
-      state2.set(3)
-    })
-    expect(getDebugCacheCreation()).toBe(1)
-    await waitFor(() => {})
-    expect(result.current).toBe(20)
-    expect(reRendersBefore).toHaveBeenCalledTimes(2)
-  })
-
-  it('should test use hook with memoize fn', async () => {
-    const state1 = create(1)
-    const state2 = create(2)
-
-    function derivedBefore(plusValue: number) {
-      return state1() + state2() + plusValue
-    }
-
-    function derived(add: number) {
-      return state1() + state2() + derivedBefore(add)
-    }
-
-    const { result } = renderHook(() => {
-      reRendersBefore()
-      const memoized = useCallback(() => derived(10), [])
-      return use(memoized)
-    })
-    expect(getDebugCacheCreation()).toBe(1)
-
-    await waitFor(() => {})
-    expect(reRendersBefore).toHaveBeenCalledTimes(1)
-    act(() => {
-      state1.set(2)
-      state2.set(3)
-    })
-    expect(getDebugCacheCreation()).toBe(1)
-    await waitFor(() => {})
-    expect(result.current).toBe(20)
-    expect(reRendersBefore).toHaveBeenCalledTimes(2)
-  })
-})

package/packages/core/create.ts

@@ -1,98 +0,0 @@
-import { canUpdate, generateId } from './utils/common'
-import type { Emitter } from './utils/create-emitter'
-import { createEmitter } from './utils/create-emitter'
-import { isEqualBase, isFunction, isSetValueFunction, isUndefined } from './utils/is'
-// import { createScheduler } from './utils/scheduler'
-import type { Cache, Callable, DefaultValue, IsEqual, Listener, SetValue } from './types'
-import { context } from './subscriber'
-import { createGlobalScheduler } from './utils/global-scheduler'
-
-export const createScheduler = createGlobalScheduler()
-interface RawState<T> {
-  (): T
-  id: number
-  set: (value: SetValue<T>) => void
-  emitter: Emitter<T>
-  listen: Listener<T>
-  destroy: () => void
-  withName: (name: string) => RawState<T>
-  stateName?: string
-}
-
-export type State<T> = {
-  readonly [K in keyof RawState<T>]: RawState<T>[K]
-} & Callable<T>
-
-export function create<T>(initialValue: DefaultValue<T>, isEqual: IsEqual<T> = isEqualBase): State<T> {
-  const cache: Cache<T> = {}
-
-  function getValue(): T {
-    if (isUndefined(cache.current)) {
-      cache.current = isFunction(initialValue) ? initialValue() : initialValue
-    }
-    return cache.current
-  }
-  function resolveValue(value: SetValue<T>) {
-    const previous = getValue()
-    cache.current = isSetValueFunction(value) ? value(previous) : value
-  }
-
-  // const schedule = createScheduler<SetValue<T>>({
-  //   onFinish() {
-  //     cache.current = getValue()
-  //     if (!canUpdate(cache, isEqual)) {
-  //       return
-  //     }
-  //     state.emitter.emit()
-  //   },
-  //   onResolveItem: resolveValue,
-  // })
-
-  const state: RawState<T> = function () {
-    const stateValue = getValue()
-    const ctx = context.use()
-    // console.log('CTX', ctx?.id, 'STATE', state.id)
-    if (ctx && !state.emitter.contains(ctx.sub)) {
-      ctx.addEmitter(state.emitter)
-    }
-    return stateValue
-  }
-  state.listen = function (listener: (value: T) => void) {
-    return state.emitter.subscribe(() => {
-      const final = cache.current
-      if (isUndefined(final)) {
-        throw new Error('The value is undefined')
-      }
-      listener(final)
-    })
-  }
-  state.emitter = createEmitter<T>(() => state())
-  state.id = generateId()
-
-  const clearScheduler = createScheduler.add(state.id, {
-    onFinish() {
-      cache.current = getValue()
-      if (!canUpdate(cache, isEqual)) {
-        return
-      }
-      state.emitter.emit()
-    },
-    onResolveItem: resolveValue,
-  })
-  state.set = function (value) {
-    createScheduler.schedule(state.id, value)
-  }
-
-  state.destroy = function () {
-    cache.current = undefined
-    getValue()
-    clearScheduler()
-    state.emitter.clear()
-  }
-  state.withName = function (name: string) {
-    state.stateName = name
-    return state
-  }
-
-  return state
-}