muya 1.1.0 → 2.0.0-beta.2

package/packages/core/utils/__tests__/is.test.ts

@@ -0,0 +1,74 @@
+import { Abort } from '../common'
+import { isPromise, isFunction, isSetValueFunction, isMap, isSet, isArray, isEqualBase, isAbortError } from '../is'
+
+describe('isPromise', () => {
+  it('should return true for a Promise', () => {
+    expect(isPromise(Promise.resolve())).toBe(true)
+  })
+  it('should return false for a non-Promise', () => {
+    expect(isPromise(123)).toBe(false)
+  })
+})
+
+describe('isFunction', () => {
+  it('should return true for a function', () => {
+    expect(isFunction(() => {})).toBe(true)
+  })
+  it('should return false for a non-function', () => {
+    expect(isFunction(123)).toBe(false)
+  })
+})
+
+describe('isSetValueFunction', () => {
+  it('should return true for a function', () => {
+    expect(isSetValueFunction(() => {})).toBe(true)
+  })
+  it('should return false for a non-function', () => {
+    expect(isSetValueFunction(123)).toBe(false)
+  })
+})
+
+describe('isMap', () => {
+  it('should return true for a Map', () => {
+    expect(isMap(new Map())).toBe(true)
+  })
+  it('should return false for a non-Map', () => {
+    expect(isMap(123)).toBe(false)
+  })
+})
+
+describe('isSet', () => {
+  it('should return true for a Set', () => {
+    expect(isSet(new Set())).toBe(true)
+  })
+  it('should return false for a non-Set', () => {
+    expect(isSet(123)).toBe(false)
+  })
+})
+
+describe('isArray', () => {
+  it('should return true for an array', () => {
+    expect(isArray([])).toBe(true)
+  })
+  it('should return false for a non-array', () => {
+    expect(isArray(123)).toBe(false)
+  })
+})
+
+describe('isEqualBase', () => {
+  it('should return true for equal values', () => {
+    expect(isEqualBase(1, 1)).toBe(true)
+  })
+  it('should return false for non-equal values', () => {
+    expect(isEqualBase(1, 2)).toBe(false)
+  })
+})
+
+describe('isAbortError', () => {
+  it('should return true for an AbortError', () => {
+    expect(isAbortError(new DOMException('', Abort.Error))).toBe(true)
+  })
+  it('should return false for a non-AbortError', () => {
+    expect(isAbortError(new DOMException('', 'Error'))).toBe(false)
+  })
+})

package/packages/core/utils/__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/packages/core/utils/__tests__/sub-memo.test.ts

@@ -0,0 +1,13 @@
+/* eslint-disable unicorn/consistent-function-scoping */
+import { subMemo } from '../sub-memo'
+
+describe('memo-fn', () => {
+  it('should create memo fn', () => {
+    function toBeMemoized(): boolean {
+      return true
+    }
+
+    const memoized = subMemo(toBeMemoized)
+    expect(memoized.call().emitter).toBeDefined()
+  })
+})

package/packages/core/utils/common.ts

@@ -0,0 +1,48 @@
+import type { Cache, IsEqual } from '../types'
+import { isUndefined } from './is'
+
+// eslint-disable-next-line no-shadow
+export enum Abort {
+  Error = 'StateAbortError',
+}
+
+export interface CancelablePromise<T> {
+  promise?: Promise<T>
+  controller?: AbortController
+  resolveInitialPromise?: (value: T) => void
+}
+/**
+ * Cancelable promise function, return promise and controller
+ */
+export function cancelablePromise<T>(promise: Promise<T>, previousController?: AbortController): CancelablePromise<T> {
+  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 }
+}
+
+let id = 0
+export function generateId() {
+  return id++
+}
+
+export function canUpdate<T>(cache: Cache<T>, isEqual: IsEqual<T> = (previous, next) => previous === next): boolean {
+  if (!isUndefined(cache.current)) {
+    if (!isUndefined(cache.previous) && isEqual(cache.current, cache.previous)) {
+      return false
+    }
+    cache.previous = cache.current
+  }
+  return true
+}

package/packages/core/utils/create-context.ts

@@ -0,0 +1,60 @@
+import { isPromise } from './is'
+
+const EMPTY_CONTEXT = Symbol('_')
+
+export function createContext<T>(defaultContextValue: T) {
+  const contextStack: Array<T | typeof EMPTY_CONTEXT> = []
+
+  function use(): T | undefined {
+    if (contextStack.length === 0) {
+      return defaultContextValue
+    }
+    const currentContext = contextStack.at(-1)
+    return currentContext === EMPTY_CONTEXT ? defaultContextValue : currentContext
+  }
+
+  function run<R>(ctxValue: T, cb: () => R | Promise<R>): R {
+    contextStack.push(ctxValue)
+    const result = cb()
+    const isResultPromise = isPromise(result)
+    if (isResultPromise) {
+      return (async () => {
+        try {
+          return await result
+        } finally {
+          contextStack.pop()
+        }
+      })() as R
+    } else {
+      contextStack.pop()
+      return result
+    }
+  }
+
+  function wrap<X>(cb: () => X | Promise<X>): () => X | Promise<X> {
+    const capturedContext = use()
+    return () => {
+      contextStack.push(capturedContext!)
+      const result = cb()
+      const isResultPromise = isPromise(result)
+      if (isResultPromise) {
+        return (async () => {
+          try {
+            return await result
+          } finally {
+            contextStack.pop()
+          }
+        })()
+      } else {
+        contextStack.pop()
+        return result
+      }
+    }
+  }
+
+  return {
+    run,
+    use,
+    wrap,
+  }
+}

package/packages/core/utils/create-emitter.ts

@@ -0,0 +1,55 @@
+export type EmitterSubscribe<P = undefined> = (listener: (...params: P[]) => void) => () => void
+export interface Emitter<T, P = undefined> {
+  subscribe: EmitterSubscribe<P>
+  subscribeToOtherEmitter: (emitter: Emitter<unknown>) => void
+  getSnapshot: () => T
+  getInitialSnapshot?: () => T
+  emit: (...params: P[]) => void
+  getSize: () => number
+  clear: () => void
+  contains: (listener: (...params: P[]) => void) => boolean
+}
+
+/**
+ * Generics parameters are:
+ * T: Type of the state
+ * R: Type of the snapshot
+ * P: Type of the parameters
+ * @param getSnapshot
+ * @returns
+ */
+export function createEmitter<T, P = undefined>(getSnapshot: () => T, getInitialSnapshot?: () => T): Emitter<T, P> {
+  const listeners = new Set<(...params: P[]) => void>()
+  // const listeners = new WeakSet<(...params: P[]) => void>()
+  const otherCleaners: Array<() => void> = []
+  return {
+    clear: () => {
+      for (const cleaner of otherCleaners) {
+        cleaner()
+      }
+
+      listeners.clear()
+    },
+    subscribe: (listener) => {
+      listeners.add(listener)
+      return () => {
+        listeners.delete(listener)
+      }
+    },
+    emit: (...params) => {
+      for (const listener of listeners) {
+        listener(...params)
+      }
+    },
+    contains: (listener) => listeners.has(listener),
+    getSnapshot,
+    getInitialSnapshot,
+    getSize: () => listeners.size,
+    subscribeToOtherEmitter(emitter) {
+      const clean = emitter.subscribe(() => {
+        this.emit()
+      })
+      otherCleaners.push(clean)
+    },
+  }
+}