muya 1.0.1 → 1.0.3

package/src/__tests__/merge.test.ts

@@ -0,0 +1,78 @@
+import { create } from '../create'
+import { renderHook, act } from '@testing-library/react'
+import { merge } from '../merge'
+
+describe('merge', () => {
+  it('should test merge multiple-state', () => {
+    const state1 = create(1)
+    const state2 = create(1)
+    const state3 = create(3)
+
+    const useMerged = merge([state1, state2, state3], (value1, value2, value3) => {
+      expect(value1).toBe(1)
+      expect(value2).toBe(1)
+      expect(value3).toBe(3)
+      return `${value1} ${value2} ${value3}`
+    })
+    const result = renderHook(() => useMerged())
+    expect(result.result.current).toBe('1 1 3')
+  })
+
+  it('should test merge multiple-state with isEqual', () => {
+    const state1 = create(1)
+    const state2 = create(1)
+    const state3 = create(3)
+
+    const useMerged = merge(
+      [state1, state2, state3],
+      (value1, value2, value3) => {
+        expect(value1).toBe(1)
+        expect(value2).toBe(1)
+        expect(value3).toBe(3)
+        return `${value1} ${value2} ${value3}`
+      },
+      (a, b) => a === b,
+    )
+    const result = renderHook(() => useMerged())
+    expect(result.result.current).toBe('1 1 3')
+  })
+
+  it('should test merge multiple-state with different type', () => {
+    const state1 = create(1)
+    const state2 = create('1')
+    const state3 = create({ value: 3 })
+    const state4 = create([1, 2, 3])
+
+    const useMerged = merge([state1, state2, state3, state4], (value1, value2, value3, value4) => {
+      expect(value1).toBe(1)
+      expect(value2).toBe('1')
+      expect(value3).toStrictEqual({ value: 3 })
+      expect(value4).toStrictEqual([1, 2, 3])
+      return `${value1} ${value2} ${value3.value} ${value4.join(' ')}`
+    })
+    const result = renderHook(() => useMerged())
+    expect(result.result.current).toBe('1 1 3 1 2 3')
+  })
+  it('should test merge with reset', () => {
+    const state1 = create(1)
+    const state2 = create(1)
+    const state3 = create(3)
+
+    const useMerged = merge([state1, state2, state3], (value1, value2, value3) => {
+      return `${value1} ${value2} ${value3}`
+    })
+    const result = renderHook(() => useMerged())
+
+    act(() => {
+      state1.setState(2)
+      state2.setState(2)
+      state3.setState(4)
+    })
+    expect(result.result.current).toBe('2 2 4')
+
+    act(() => {
+      useMerged.reset()
+    })
+    expect(result.result.current).toBe('1 1 3')
+  })
+})

package/src/__tests__/shallow.test.ts

@@ -0,0 +1,418 @@
+import { shallow } from '../shallow'
+
+describe('shallow', () => {
+  it('should return true for identical primitive values', () => {
+    expect(shallow(1, 1)).toBe(true)
+    expect(shallow('a', 'a')).toBe(true)
+    expect(shallow(true, true)).toBe(true)
+  })
+
+  it('should return false for different primitive values', () => {
+    expect(shallow(1, 2)).toBe(false)
+    expect(shallow('a', 'b')).toBe(false)
+    expect(shallow(true, false)).toBe(false)
+  })
+
+  it('should return true for identical objects', () => {
+    const object = { a: 1 }
+    expect(shallow(object, object)).toBe(true)
+  })
+
+  it('should return false for different objects with diff properties', () => {
+    expect(shallow({ a: 1 }, { a: 2 })).toBe(false)
+  })
+
+  it('should return true for identical arrays', () => {
+    const array = [1, 2, 3]
+    expect(shallow(array, array)).toBe(true)
+  })
+
+  it('should return true for different arrays with same elements', () => {
+    expect(shallow([1, 2, 3], [1, 2, 3])).toBe(true)
+  })
+
+  it('should return true for identical Maps', () => {
+    const map = new Map([['a', 1]])
+    expect(shallow(map, map)).toBe(true)
+  })
+
+  it('should return true for different Maps with same entries', () => {
+    expect(shallow(new Map([['a', 1]]), new Map([['a', 1]]))).toBe(true)
+  })
+
+  it('should return true for identical Sets', () => {
+    const set = new Set([1, 2, 3])
+    expect(shallow(set, set)).toBe(true)
+  })
+
+  it('should return true for different Sets with same elements', () => {
+    expect(shallow(new Set([1, 2, 3]), new Set([1, 2, 3]))).toBe(true)
+  })
+
+  it('should return true for objects with same reference', () => {
+    const object = { a: 1 }
+    expect(shallow(object, object)).toBe(true)
+  })
+
+  it('should return true for objects with different references', () => {
+    expect(shallow({ a: 1 }, { a: 1 })).toBe(true)
+  })
+
+  it('should return true for arrays with same reference', () => {
+    const array = [1, 2, 3]
+    expect(shallow(array, array)).toBe(true)
+  })
+
+  it('should return true for arrays with different references', () => {
+    expect(shallow([1, 2, 3], [1, 2, 3])).toBe(true)
+  })
+
+  it('should return true for Maps with same reference', () => {
+    const map = new Map([['a', 1]])
+    expect(shallow(map, map)).toBe(true)
+  })
+
+  it('should return true for Maps with different references', () => {
+    expect(shallow(new Map([['a', 1]]), new Map([['a', 1]]))).toBe(true)
+  })
+
+  it('should return true for Sets with same reference', () => {
+    const set = new Set([1, 2, 3])
+    expect(shallow(set, set)).toBe(true)
+  })
+
+  it('should return true for Sets with different references', () => {
+    expect(shallow(new Set([1, 2, 3]), new Set([1, 2, 3]))).toBe(true)
+  })
+
+  it('should return true for objects with same keys and values', () => {
+    const objectA = { a: 1, b: 2 }
+    const objectB = { a: 1, b: 2 }
+    expect(shallow(objectA, objectB)).toBe(true)
+  })
+
+  it('should return false for objects with different keys or values', () => {
+    const objectA = { a: 1, b: 2 }
+    const objectB = { a: 1, b: 3 }
+    expect(shallow(objectA, objectB)).toBe(false)
+  })
+
+  it('should return true for arrays with same elements', () => {
+    const arrayA = [1, 2, 3]
+    const arrayB = [1, 2, 3]
+    expect(shallow(arrayA, arrayB)).toBe(true)
+  })
+
+  it('should return false for arrays with different elements', () => {
+    const arrayA = [1, 2, 3]
+    const arrayB = [1, 2, 4]
+    expect(shallow(arrayA, arrayB)).toBe(false)
+  })
+
+  it('should return true for Maps with same entries', () => {
+    const mapA = new Map([
+      ['a', 1],
+      ['b', 2],
+    ])
+    const mapB = new Map([
+      ['a', 1],
+      ['b', 2],
+    ])
+    expect(shallow(mapA, mapB)).toBe(true)
+  })
+
+  it('should return false for Maps with different entries', () => {
+    const mapA = new Map([
+      ['a', 1],
+      ['b', 2],
+    ])
+    const mapB = new Map([
+      ['a', 1],
+      ['b', 3],
+    ])
+    expect(shallow(mapA, mapB)).toBe(false)
+  })
+
+  it('should return true for Sets with same elements', () => {
+    const setA = new Set([1, 2, 3])
+    const setB = new Set([1, 2, 3])
+    expect(shallow(setA, setB)).toBe(true)
+  })
+
+  it('should return false for Sets with different elements', () => {
+    const setA = new Set([1, 2, 3])
+    const setB = new Set([1, 2, 4])
+    expect(shallow(setA, setB)).toBe(false)
+  })
+
+  it('should return false for different objects with same properties', () => {
+    expect(shallow({ a: 1 }, { a: 2 })).toBe(false)
+  })
+
+  it('should return false for different arrays with same elements', () => {
+    expect(shallow([1, 2, 3], [1, 2, 4])).toBe(false)
+  })
+
+  it('should return false for different Maps with same entries', () => {
+    expect(shallow(new Map([['a', 1]]), new Map([['a', 2]]))).toBe(false)
+  })
+
+  it('should return false for different Sets with same elements', () => {
+    expect(shallow(new Set([1, 2, 3]), new Set([1, 2, 4]))).toBe(false)
+  })
+
+  it('should return false for objects with different reference', () => {
+    expect(shallow({ a: 1 }, { a: 2 })).toBe(false)
+  })
+
+  it('should return false for arrays with different reference', () => {
+    expect(shallow([1, 2, 3], [1, 2, 4])).toBe(false)
+  })
+
+  it('should return false for Maps with different reference', () => {
+    expect(shallow(new Map([['a', 1]]), new Map([['a', 2]]))).toBe(false)
+  })
+
+  it('should return false for Sets with different reference', () => {
+    expect(shallow(new Set([1, 2, 3]), new Set([1, 2, 4]))).toBe(false)
+  })
+
+  it('should return false for objects with different keys or values in', () => {
+    const objectA = { a: 1, b: 2 }
+    const objectB = { a: 1, b: 3 }
+    expect(shallow(objectA, objectB)).toBe(false)
+  })
+
+  it('should return false for arrays with different elements', () => {
+    const arrayA = [1, 2, 3]
+    const arrayB = [1, 2, 4]
+    expect(shallow(arrayA, arrayB)).toBe(false)
+  })
+
+  it('should return false for Maps with different entries', () => {
+    const mapA = new Map([
+      ['a', 1],
+      ['b', 2],
+    ])
+    const mapB = new Map([
+      ['a', 1],
+      ['b', 3],
+    ])
+    expect(shallow(mapA, mapB)).toBe(false)
+  })
+
+  it('should return false for Sets with different elements', () => {
+    const setA = new Set([1, 2, 3])
+    const setB = new Set([1, 2, 4])
+    expect(shallow(setA, setB)).toBe(false)
+  })
+
+  it('should return false for objects with different keys or values', () => {
+    const objectA = { a: 1, b: 2 }
+    const objectB = { a: 1, b: 3 }
+    expect(shallow(objectA, objectB)).toBe(false)
+  })
+
+  it('should return false for arrays with different elements', () => {
+    const arrayA = [1, 2, 3]
+    const arrayB = [1, 2, 4]
+    expect(shallow(arrayA, arrayB)).toBe(false)
+  })
+
+  it('should return false for Maps with different entries', () => {
+    const mapA = new Map([
+      ['a', 1],
+      ['b', 2],
+    ])
+    const mapB = new Map([
+      ['a', 1],
+      ['b', 3],
+    ])
+    expect(shallow(mapA, mapB)).toBe(false)
+  })
+
+  it('should return false for Sets with different elements', () => {
+    const setA = new Set([1, 2, 3])
+    const setB = new Set([1, 2, 4])
+    expect(shallow(setA, setB)).toBe(false)
+  })
+
+  it('should return false for objects with different keys or values', () => {
+    const objectA = { a: 1, b: 2 }
+    const objectB = { a: 1, b: 3 }
+    expect(shallow(objectA, objectB)).toBe(false)
+  })
+
+  it('should return false for arrays with different elements', () => {
+    const arrayA = [1, 2, 3]
+    const arrayB = [1, 2, 4]
+    expect(shallow(arrayA, arrayB)).toBe(false)
+  })
+
+  it('should return false for Maps with different entries', () => {
+    const mapA = new Map([
+      ['a', 1],
+      ['b', 2],
+    ])
+    const mapB = new Map([
+      ['a', 1],
+      ['b', 3],
+    ])
+    expect(shallow(mapA, mapB)).toBe(false)
+  })
+
+  it('should return false for Sets with different elements', () => {
+    const setA = new Set([1, 2, 3])
+    const setB = new Set([1, 2, 4])
+    expect(shallow(setA, setB)).toBe(false)
+  })
+
+  it('should return false for objects with different keys or values', () => {
+    const objectA = { a: 1, b: 2 }
+    const objectB = { a: 1, b: 3 }
+    expect(shallow(objectA, objectB)).toBe(false)
+  })
+
+  it('should return false for arrays with different elements', () => {
+    const arrayA = [1, 2, 3]
+    const arrayB = [1, 2, 4]
+    expect(shallow(arrayA, arrayB)).toBe(false)
+  })
+
+  it('should return false for Maps with different entries', () => {
+    const mapA = new Map([
+      ['a', 1],
+      ['b', 2],
+    ])
+    const mapB = new Map([
+      ['a', 1],
+      ['b', 3],
+    ])
+    expect(shallow(mapA, mapB)).toBe(false)
+  })
+
+  it('should return false for Sets with different elements', () => {
+    const setA = new Set([1, 2, 3])
+    const setB = new Set([1, 2, 4])
+    expect(shallow(setA, setB)).toBe(false)
+  })
+
+  it('should return false for objects with different keys or values', () => {
+    const objectA = { a: 1, b: 2 }
+    const objectB = { a: 1, b: 3 }
+    expect(shallow(objectA, objectB)).toBe(false)
+  })
+
+  it('should return false for arrays with different elements', () => {
+    const arrayA = [1, 2, 3]
+    const arrayB = [1, 2, 4]
+    expect(shallow(arrayA, arrayB)).toBe(false)
+  })
+
+  it('should return false for Maps with different entries', () => {
+    const mapA = new Map([
+      ['a', 1],
+      ['b', 2],
+    ])
+    const mapB = new Map([
+      ['a', 1],
+      ['b', 3],
+    ])
+    expect(shallow(mapA, mapB)).toBe(false)
+  })
+
+  it('should return false for Sets with different elements', () => {
+    const setA = new Set([1, 2, 3])
+    const setB = new Set([1, 2, 4])
+    expect(shallow(setA, setB)).toBe(false)
+  })
+
+  it('should return false for objects with different keys or values', () => {
+    const objectA = { a: 1, b: 2 }
+    const objectB = { a: 1, b: 3 }
+    expect(shallow(objectA, objectB)).toBe(false)
+  })
+
+  it('should return false for arrays with different elements', () => {
+    const arrayA = [1, 2, 3]
+    const arrayB = [1, 2, 4]
+    expect(shallow(arrayA, arrayB)).toBe(false)
+  })
+
+  it('should return false for Maps with different entries', () => {
+    const mapA = new Map([
+      ['a', 1],
+      ['b', 2],
+    ])
+    const mapB = new Map([
+      ['a', 1],
+      ['b', 3],
+    ])
+    expect(shallow(mapA, mapB)).toBe(false)
+  })
+
+  it('should return false for Sets with different elements', () => {
+    const setA = new Set([1, 2, 3])
+    const setB = new Set([1, 2, 4])
+    expect(shallow(setA, setB)).toBe(false)
+  })
+
+  it('should return false for null and non-null values', () => {
+    expect(shallow(null, {})).toBe(false)
+    expect(shallow({}, null)).toBe(false)
+  })
+
+  it('should return false for objects with different number of keys', () => {
+    expect(shallow({ a: 1 }, { a: 1, b: 2 })).toBe(false)
+  })
+
+  it('should return false for objects with different keys', () => {
+    expect(shallow({ a: 1 }, { b: 1 })).toBe(false)
+  })
+
+  it('should return false for objects with different values', () => {
+    expect(shallow({ a: 1 }, { a: 2 })).toBe(false)
+  })
+
+  it('should return false for arrays with different lengths', () => {
+    expect(shallow([1, 2], [1, 2, 3])).toBe(false)
+  })
+
+  it('should return false for arrays with different elements', () => {
+    expect(shallow([1, 2, 3], [1, 2, 4])).toBe(false)
+  })
+
+  it('should return false for Maps with different sizes', () => {
+    expect(
+      shallow(
+        new Map([['a', 1]]),
+        new Map([
+          ['a', 1],
+          ['b', 2],
+        ]),
+      ),
+    ).toBe(false)
+  })
+
+  it('should return false for Maps with different keys', () => {
+    expect(shallow(new Map([['a', 1]]), new Map([['b', 1]]))).toBe(false)
+  })
+
+  it('should return false for Maps with different values', () => {
+    expect(shallow(new Map([['a', 1]]), new Map([['a', 2]]))).toBe(false)
+  })
+
+  it('should return false for Sets with different sizes', () => {
+    expect(shallow(new Set([1, 2]), new Set([1, 2, 3]))).toBe(false)
+  })
+
+  it('should return false for Sets with different elements', () => {
+    expect(shallow(new Set([1, 2, 3]), new Set([1, 2, 4]))).toBe(false)
+  })
+
+  it('should return true compare simple values', () => {
+    expect(shallow(1, 1)).toBe(true)
+    expect(shallow('a', 'a')).toBe(true)
+    expect(shallow(true, true)).toBe(true)
+  })
+})

package/src/{state.test.tsx → __tests__/state.test.tsx}

@@ -1,9 +1,9 @@
 /* eslint-disable @typescript-eslint/no-shadow */
 /* eslint-disable no-shadow */
 import { Suspense } from 'react'
-import { create } from './create'
+import { create } from '../create'
 import { renderHook, act, waitFor, render, screen } from '@testing-library/react'
-import { shallow } from './shallow'
+import { shallow } from '../shallow'
 describe('state', () => {
   it('should test state', () => {
     const appState = create({ count: 0 })
@@ -485,34 +485,6 @@ describe('state', () => {
     })
     expect(renderCount.current).toEqual(1)
   })
-  it('should use merge states', () => {
-    const state1 = create(3)
-    const state2 = create(2)
-    const mergedState = state1.merge(state2, (s1, s2) => s1 + s2)
-    const result = renderHook(() => mergedState())
-    expect(result.result.current).toEqual(5)
-    act(() => {
-      state1.setState(5)
-    })
-    expect(result.result.current).toEqual(7)
-    act(() => {
-      state2.setState(3)
-    })
-    expect(result.result.current).toEqual(8)
-  })
-
-  it('should use merge states nested', () => {
-    const useName = create(() => 'John')
-    const useAge = create(() => 30)
-    const useUser = useName.merge(useAge, (name, age) => ({ name, age }), shallow)
-    const result = renderHook(() => useUser())
-    expect(result.result.current).toEqual({ name: 'John', age: 30 })
-
-    act(() => {
-      useName.setState('Jane')
-    })
-    expect(result.result.current).toEqual({ name: 'Jane', age: 30 })
-  })
 
   it('should use slice with new reference', () => {
     const useName = create(() => 'John')

package/src/__tests__/test-utils.ts

@@ -0,0 +1,40 @@
+import { Component } from 'react'
+
+export function longPromise(time = 200): Promise<number> {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(0)
+    }, time)
+  })
+}
+
+// ErrorBoundary Component
+export class ErrorBoundary extends Component<
+  { fallback: React.ReactNode; children: React.ReactNode },
+  { hasError: boolean; error: Error | null }
+> {
+  constructor(props: { fallback: React.ReactNode; children: React.ReactNode }) {
+    super(props)
+    this.state = { hasError: false, error: null }
+  }
+
+  static getDerivedStateFromError(error: Error) {
+    // Update state so the next render shows the fallback UI.
+    return { hasError: true, error }
+  }
+
+  componentDidCatch(error: Error, errorInfo: React.ErrorInfo) {
+    // You can log the error to an error reporting service here
+    // eslint-disable-next-line no-console
+    console.error('ErrorBoundary caught an error:', error, errorInfo)
+  }
+
+  render() {
+    if (this.state.hasError) {
+      // Render fallback UI
+      return this.props.fallback
+    }
+
+    return this.props.children
+  }
+}

package/src/__tests__/types.test.ts

@@ -0,0 +1,17 @@
+import { getDefaultValue } from '../types'
+
+describe('getDefaultValue', () => {
+  it('should return the value if it is not a function or promise', () => {
+    expect(getDefaultValue(123)).toBe(123)
+  })
+
+  it('should return the resolved value if it is a function', () => {
+    expect(getDefaultValue(() => 123)).toBe(123)
+  })
+
+  it('should return the promise if it is a promise', () => {
+    const promise = Promise.resolve(123)
+    expect(getDefaultValue(promise)).toBe(promise)
+    expect(getDefaultValue(() => promise)).toBe(promise)
+  })
+})

package/src/common.ts

@@ -26,3 +26,35 @@ export function useSyncExternalStore<T, S>(
   useDebugValue(value)
   return value
 }
+// eslint-disable-next-line no-shadow
+export enum Abort {
+  Error = 'StateAbortError',
+}
+/**
+ * Cancelable promise function, return promise and controller
+ */
+export function cancelablePromise<T>(
+  promise: Promise<T>,
+  previousController?: AbortController,
+): {
+  promise: Promise<T>
+  controller: AbortController
+} {
+  if (previousController) {
+    previousController.abort()
+  }
+  const controller = new AbortController()
+  const { signal } = controller
+
+  const cancelable = new Promise<T>((resolve, reject) => {
+    // Listen for the abort event
+    signal.addEventListener('abort', () => {
+      reject(new DOMException('Promise was aborted', Abort.Error))
+    })
+
+    // When the original promise settles, resolve or reject accordingly
+    promise.then(resolve).catch(reject)
+  })
+
+  return { promise: cancelable, controller }
+}

package/src/create-base-state.ts

@@ -1,5 +1,4 @@
 import type { Emitter } from './create-emitter'
-import { merge } from './merge'
 import { select } from './select'
 import type { BaseState, GetterState } from './types'
 
@@ -18,10 +17,7 @@ export function createBaseState<T>(options: Options<T>): BaseState<T> {
       const state = getGetterState()
       return select(state, selector, isSame)
     },
-    merge(state2, selector, isEqualHook) {
-      const state = getGetterState()
-      return merge(state, state2, selector, isEqualHook)
-    },
+
     __internal: {
       emitter,
     },

package/src/create-getter-state.ts

@@ -13,7 +13,6 @@ export function createGetterState<T>(options: Options<T>): GetterState<T> {
   useSliceState.getState = baseState.getState
   useSliceState.reset = baseState.reset
   useSliceState.select = baseState.select
-  useSliceState.merge = baseState.merge
   useSliceState.subscribe = baseState.subscribe
   return useSliceState
 }