muya 1.1.0 → 2.0.0-beta.1

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,53 @@
+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 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)
+    },
+  }
+}

package/packages/core/utils/is.ts

@@ -0,0 +1,43 @@
+import { Abort } from './common'
+import type { SetStateCb, SetValue } from '../types'
+
+export function isPromise<T>(value: unknown): value is Promise<T> {
+  return value instanceof Promise
+}
+
+export function isFunction<T extends (...args: unknown[]) => unknown>(value: unknown): value is T {
+  return typeof value === 'function'
+}
+
+export function isMap(value: unknown): value is Map<unknown, unknown> {
+  return value instanceof Map
+}
+
+export function isSet(value: unknown): value is Set<unknown> {
+  return value instanceof Set
+}
+
+export function isArray(value: unknown): value is Array<unknown> {
+  return Array.isArray(value)
+}
+
+export function isEqualBase<T>(valueA: T, valueB: T): boolean {
+  if (valueA === valueB) {
+    return true
+  }
+  return !!Object.is(valueA, valueB)
+}
+export function isSetValueFunction<T>(value: SetValue<T>): value is SetStateCb<T> {
+  return typeof value === 'function'
+}
+export function isAbortError(value: unknown): value is DOMException {
+  return value instanceof DOMException && value.name === Abort.Error
+}
+
+export function isAnyOtherError(value: unknown): value is Error {
+  return value instanceof Error && value.name !== Abort.Error
+}
+
+export function isUndefined(value: unknown): value is undefined {
+  return value === undefined
+}

package/packages/core/utils/scheduler.ts

@@ -0,0 +1,59 @@
+const THRESHOLD = 0.2
+const THRESHOLD_ITEMS = 10
+const RESCHEDULE_COUNT = 0
+
+interface Options<T> {
+  readonly onResolveItem?: (item: T) => void
+  readonly onFinish: () => void
+}
+
+export function createScheduler<T>(options: Options<T>) {
+  const batches = new Set<T>()
+  const { onResolveItem, onFinish } = options
+  let frame = performance.now()
+  let scheduled = false
+
+  function schedule() {
+    const startFrame = performance.now()
+    const frameSizeDiffIn = startFrame - frame
+    const { size } = batches
+    if (frameSizeDiffIn < THRESHOLD && size > 0 && size < THRESHOLD_ITEMS) {
+      frame = startFrame
+      flush()
+      return
+    }
+
+    if (!scheduled) {
+      scheduled = true
+      Promise.resolve().then(() => {
+        scheduled = false
+        frame = performance.now()
+        flush()
+      })
+    }
+  }
+
+  function flush() {
+    if (batches.size === 0) {
+      return
+    }
+    for (const value of batches) {
+      if (onResolveItem) {
+        onResolveItem(value)
+      }
+      batches.delete(value)
+    }
+
+    if (batches.size > RESCHEDULE_COUNT) {
+      schedule()
+      return
+    }
+    onFinish()
+  }
+
+  function addValue(value: T) {
+    batches.add(value)
+    schedule()
+  }
+  return addValue
+}