muya 1.1.0 → 2.0.0-beta.1

package/packages/core/subscriber.ts

@@ -0,0 +1,121 @@
+import type { AnyFunction, Cache, Callable, Listener } from './types'
+import type { CancelablePromise } from './utils/common'
+import { cancelablePromise, canUpdate, generateId } from './utils/common'
+import { createContext } from './utils/create-context'
+import type { Emitter } from './utils/create-emitter'
+import { createEmitter } from './utils/create-emitter'
+import { isAbortError, isEqualBase, isPromise, isUndefined } from './utils/is'
+
+interface SubscribeContext<T = unknown> {
+  addEmitter: (emitter: Emitter<T>) => void
+  id: number
+  sub: () => void
+}
+interface SubscribeRaw<F extends AnyFunction, T extends ReturnType<F> = ReturnType<F>> {
+  (): T
+  emitter: Emitter<T | undefined>
+  destroy: () => void
+  id: number
+  listen: Listener<T>
+  abort: () => void
+}
+
+export type Subscribe<F extends AnyFunction, T extends ReturnType<F> = ReturnType<F>> = {
+  readonly [K in keyof SubscribeRaw<F, T>]: SubscribeRaw<F, T>[K]
+} & Callable<T>
+
+export const context = createContext<SubscribeContext | undefined>(undefined)
+
+export function subscriber<F extends AnyFunction, T extends ReturnType<F> = ReturnType<F>>(
+  anyFunction: () => T,
+): Subscribe<F, T> {
+  const cleaners: Array<() => void> = []
+  const promiseData: CancelablePromise<T> = {}
+
+  const cache: Cache<T> = {}
+  let isInitialized = false
+  const emitter = createEmitter(
+    () => {
+      if (!isInitialized) {
+        isInitialized = true
+        return subscribe()
+      }
+      return cache.current
+    },
+    () => {
+      isInitialized = true
+      return subscribe()
+    },
+  )
+
+  async function sub() {
+    if (!canUpdate(cache, isEqualBase)) {
+      return
+    }
+    if (promiseData.controller) {
+      promiseData.controller.abort()
+    }
+
+    cache.current = subscribe()
+    emitter.emit()
+  }
+  const id = generateId()
+  const ctx: SubscribeContext = {
+    addEmitter(stateEmitter) {
+      const clean = stateEmitter.subscribe(sub)
+      cleaners.push(clean)
+    },
+    id,
+    sub,
+  }
+
+  const subscribe = function (): T {
+    const resultValue = context.run(ctx, anyFunction)
+
+    if (isPromise(resultValue)) {
+      const { controller, promise: promiseWithSelector } = cancelablePromise<T>(resultValue, promiseData.controller)
+      promiseData.controller = controller
+      promiseWithSelector
+        ?.then((value) => {
+          cache.current = value
+          emitter.emit()
+        })
+        .catch((error) => {
+          if (isAbortError(error)) {
+            return
+          }
+
+          throw error
+        })
+      const promiseResult = promiseWithSelector as T
+      cache.current = promiseResult
+      return promiseResult
+    }
+    cache.current = resultValue
+    return resultValue
+  }
+
+  subscribe.emitter = emitter
+  subscribe.destroy = function () {
+    for (const cleaner of cleaners) {
+      cleaner()
+    }
+    emitter.clear()
+  }
+  subscribe.id = id
+  subscribe.listen = function (listener: (value: T) => void) {
+    return emitter.subscribe(() => {
+      const final = cache.current
+      if (isUndefined(final)) {
+        throw new Error('The value is undefined')
+      }
+      listener(final)
+    })
+  }
+  subscribe.abort = function () {
+    if (promiseData.controller) {
+      promiseData.controller.abort()
+    }
+  }
+  return subscribe
+}

package/packages/core/types.ts

@@ -0,0 +1,15 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type AnyFunction = (...args: any[]) => any
+
+export type IsEqual<T = unknown> = (a: T, b: T) => boolean
+export type SetStateCb<T> = (value: T) => Awaited<T>
+export type SetValue<T> = SetStateCb<T> | Awaited<T>
+export type DefaultValue<T> = T | (() => T)
+export type Listener<T> = (listener: (value: T) => void) => () => void
+export interface Cache<T> {
+  current?: T
+  previous?: T
+}
+export type Callable<T> = () => T
+
+export const EMPTY_SELECTOR = <T>(stateValue: T) => stateValue

package/packages/core/use.ts

@@ -0,0 +1,59 @@
+/* eslint-disable react-hooks/rules-of-hooks */
+/* eslint-disable sonarjs/rules-of-hooks */
+import { useDebugValue, useEffect, useRef } from 'react'
+import { EMPTY_SELECTOR, type AnyFunction } from './types'
+import { isAnyOtherError, isPromise } from './utils/is'
+import { useSyncExternalStore } from 'react'
+import { subMemo } from './utils/sub-memo'
+
+const PROMOTE_DEBUG_AFTER_REACH_TIMES = 10
+const PROMOTE_DEBUG_AFTER_REACH_COUNT = 3
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function useDebugFunction<F extends AnyFunction>(function_: F) {
+  const renderCount = useRef({ renders: 0, startTime: performance.now() })
+  useEffect(() => {
+    renderCount.current.renders++
+    const passedTime = performance.now() - renderCount.current.startTime
+    if (passedTime < PROMOTE_DEBUG_AFTER_REACH_TIMES) {
+      return
+    }
+    if (renderCount.current.renders < PROMOTE_DEBUG_AFTER_REACH_COUNT) {
+      return
+    }
+    renderCount.current.startTime = performance.now()
+    renderCount.current.renders = 0
+    // eslint-disable-next-line no-console
+    console.warn(
+      `Function ${function_.name.length > 0 ? function_.name : function_} seems to be not memoized, wrap the function to the useCallback or use global defined functions.`,
+    )
+  }, [function_])
+}
+
+export function use<F extends AnyFunction, T extends ReturnType<F>, S extends ReturnType<F>>(
+  anyFunction: () => T,
+  selector: (stateValue: T) => S = EMPTY_SELECTOR,
+): undefined extends S ? T : S {
+  const memo = subMemo(anyFunction)
+  const sub = memo.call()
+  const initialSnapshot = sub.emitter.getInitialSnapshot ?? sub.emitter.getSnapshot
+  useEffect(() => {
+    // memo.call()
+    return memo.destroy
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [anyFunction])
+
+  const value = useSyncExternalStore<S>(
+    sub.emitter.subscribe,
+    () => selector(sub.emitter.getSnapshot() as T),
+    () => selector(initialSnapshot() as T),
+  )
+  useDebugValue(value)
+  if (isPromise(value)) {
+    throw value
+  }
+  if (isAnyOtherError(value)) {
+    memo.destroy()
+    throw value
+  }
+  return value
+}

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

@@ -0,0 +1,198 @@
+/* eslint-disable sonarjs/pseudo-random */
+/* eslint-disable sonarjs/no-nested-functions */
+import { createContext } from '../create-context'
+import { longPromise } from '../../__tests__/test-utils'
+
+describe('context', () => {
+  it('should check context', () => {
+    const context = createContext({ name: 'John Doe' })
+
+    const main = () => {
+      context.run({ name: 'Jane Doe' }, () => {
+        expect(context.use()).toEqual({ name: 'Jane Doe' })
+      })
+    }
+    expect(context.use()).toEqual({ name: 'John Doe' })
+    main()
+    expect(context.use()).toEqual({ name: 'John Doe' })
+  })
+
+  it('should test async context', (done) => {
+    const context = createContext<string>('empty')
+    // eslint-disable-next-line unicorn/consistent-function-scoping
+    const awaiter = async () => new Promise((resolve) => setTimeout(resolve, 10))
+    context.run('outer', () => {
+      expect(context.use()).toEqual('outer')
+
+      // Wrap the asynchronous callback to preserve 'outer' context
+      setTimeout(
+        context.wrap(async () => {
+          try {
+            await awaiter()
+            expect(context.use()).toEqual('outer')
+            innerDone()
+          } catch (error) {
+            done(error)
+          }
+        }),
+        10,
+      )
+
+      context.run('inner', () => {
+        expect(context.use()).toEqual('inner')
+
+        // Wrap the asynchronous callback to preserve 'inner' context
+        setTimeout(
+          context.wrap(() => {
+            try {
+              expect(context.use()).toEqual('inner')
+              innerDone()
+            } catch (error) {
+              done(error)
+            }
+          }),
+          10,
+        )
+      })
+
+      expect(context.use()).toEqual('outer')
+    })
+
+    let completed = 0
+    function innerDone() {
+      completed += 1
+      if (completed === 2) {
+        done()
+      }
+    }
+  })
+  it('should test async nested context', (done) => {
+    const context = createContext(0)
+    context.run(1, () => {
+      expect(context.use()).toEqual(1)
+      context.run(2, () => {
+        context.run(3, () => {
+          expect(context.use()).toEqual(3)
+          setTimeout(
+            context.wrap(() => {
+              expect(context.use()).toEqual(3)
+            }),
+            10,
+          )
+          expect(context.use()).toEqual(3)
+        })
+        setTimeout(
+          context.wrap(() => {
+            expect(context.use()).toEqual(2)
+          }),
+          10,
+        )
+        expect(context.use()).toEqual(2)
+        context.run(3, () => {
+          expect(context.use()).toEqual(3)
+          setTimeout(
+            context.wrap(() => {
+              expect(context.use()).toEqual(3)
+              context.run(4, () => {
+                expect(context.use()).toEqual(4)
+                setTimeout(
+                  context.wrap(() => {
+                    expect(context.use()).toEqual(4)
+                    done()
+                  }),
+                  10,
+                )
+                expect(context.use()).toEqual(4)
+              })
+            }),
+            10,
+          )
+          expect(context.use()).toEqual(3)
+        })
+        // check back to 2
+        expect(context.use()).toEqual(2)
+      })
+      // check back to 1
+      expect(context.use()).toEqual(1)
+    })
+    // check back to 0
+    expect(context.use()).toEqual(0)
+  })
+  it('should stress test context with async random code', async () => {
+    const stressCount = 10_000
+    const context = createContext(0)
+    for (let index = 0; index < stressCount; index++) {
+      context.run(index, () => {
+        expect(context.use()).toEqual(index)
+      })
+    }
+
+    const promises: Promise<unknown>[] = []
+    for (let index = 0; index < stressCount; index++) {
+      context.run(index, () => {
+        expect(context.use()).toEqual(index)
+        const promise = new Promise((resolve) => {
+          setTimeout(
+            context.wrap(() => {
+              expect(context.use()).toEqual(index)
+              resolve(index)
+            }),
+            Math.random() * 100,
+          )
+        })
+        promises.push(promise)
+      })
+    }
+    await Promise.all(promises)
+  })
+
+  it('should-test-default-value-with-ctx', async () => {
+    const ctx = createContext({ counter: 1 })
+    ctx.run({ counter: 10 }, async () => {
+      await longPromise(10)
+      expect(ctx.use()?.counter).toBe(10)
+    })
+    ctx.run({ counter: 12 }, () => {
+      expect(ctx.use()?.counter).toBe(12)
+    })
+  })
+  it('should test nested context', () => {
+    const currentCount = 0
+    const context = createContext({ count: 0 })
+    function container() {
+      const isIn = context.use()
+      expect(isIn?.count).toBe(currentCount)
+      context.run({ count: currentCount + 1 }, () => {
+        const inner = context.use()
+        expect(inner?.count).toBe(currentCount + 1)
+        context.run({ count: currentCount + 2 }, () => {
+          const innerInner = context.use()
+          expect(innerInner?.count).toBe(currentCount + 2)
+        })
+      })
+    }
+
+    container()
+    container()
+  })
+
+  it('should test nested context with async when promise is returned, but not waited', async () => {
+    const context = createContext({ count: 0 })
+
+    async function insideContextNestedAwaited() {
+      await longPromise(10)
+      const ctx = context.use()
+      expect(ctx?.count).toBe(1)
+    }
+    async function insideContext() {
+      await insideContextNestedAwaited()
+      // HERE THIS IS NOT WAITED, SO CONTEXT IS LOST.
+      // insideContextNestedAwaited() // this will not work
+      context.wrap(insideContextNestedAwaited) // this work
+      const ctx = context.use()
+      expect(ctx?.count).toBe(1)
+    }
+
+    context.run({ count: 1 }, insideContext)
+  })
+})

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)
+  })
+})