muya 1.0.3 → 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/{src → packages/core/utils}/__tests__/is.test.ts

@@ -1,16 +1,5 @@
 import { Abort } from '../common'
-import {
-  isPromise,
-  isFunction,
-  isSetValueFunction,
-  isObject,
-  isRef,
-  isMap,
-  isSet,
-  isArray,
-  isEqualBase,
-  isAbortError,
-} from '../is'
+import { isPromise, isFunction, isSetValueFunction, isMap, isSet, isArray, isEqualBase, isAbortError } from '../is'
 
 describe('isPromise', () => {
   it('should return true for a Promise', () => {
@@ -39,24 +28,6 @@ describe('isSetValueFunction', () => {
   })
 })
 
-describe('isObject', () => {
-  it('should return true for an object', () => {
-    expect(isObject({})).toBe(true)
-  })
-  it('should return false for a non-object', () => {
-    expect(isObject(123)).toBe(false)
-  })
-})
-
-describe('isRef', () => {
-  it('should return true for a ref object', () => {
-    expect(isRef({ isRef: true })).toBe(true)
-  })
-  it('should return false for a non-ref object', () => {
-    expect(isRef({})).toBe(false)
-  })
-})
-
 describe('isMap', () => {
   it('should return true for a Map', () => {
     expect(isMap(new Map())).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/{src → packages/core/utils}/is.ts

@@ -1,21 +1,13 @@
 import { Abort } from './common'
-import type { Ref, Setter, SetValue } from './types'
+import type { SetStateCb, SetValue } from '../types'
 
-export function isPromise(value: unknown): value is Promise<unknown> {
+export function isPromise<T>(value: unknown): value is Promise<T> {
   return value instanceof Promise
 }
-export function isFunction(value: unknown): value is (...args: unknown[]) => unknown {
-  return typeof value === 'function'
-}
-export function isSetValueFunction<T>(value: SetValue<T>): value is Setter<T> {
+
+export function isFunction<T extends (...args: unknown[]) => unknown>(value: unknown): value is T {
   return typeof value === 'function'
 }
-export function isObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null
-}
-export function isRef<T>(value: unknown): value is Ref<T> {
-  return isObject(value) && value.isRef === true
-}
 
 export function isMap(value: unknown): value is Map<unknown, unknown> {
   return value instanceof Map
@@ -35,7 +27,9 @@ export function isEqualBase<T>(valueA: T, valueB: T): boolean {
   }
   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
 }
@@ -43,3 +37,7 @@ export function isAbortError(value: unknown): value is DOMException {
 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
+}