muya 2.0.0-beta.2 → 2.0.0

package/packages/core/subscriber.ts

@@ -1,165 +0,0 @@
-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 type { StateType } from './debug/development-tools'
-import { developmentToolsListener, sendToDevelopmentTools } from './debug/development-tools'
-import { createGlobalScheduler } from './utils/global-scheduler'
-import { isAbortError, isCreate, isEqualBase, isPromise, isUndefined } from './utils/is'
-
-const subscriberScheduler = createGlobalScheduler()
-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 cache: Cache<T> = {}
-  let isInitialized = false
-  const cleaners: Array<() => void> = []
-  const promiseData: CancelablePromise<T> = {}
-
-  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()
-    }
-
-    subscriberScheduler.schedule(id, null)
-  }
-
-  const id = generateId()
-
-  const clearScheduler = subscriberScheduler.add(id, {
-    onFinish() {
-      cache.current = subscribe()
-      emitter.emit()
-    },
-  })
-  const ctx: SubscribeContext = {
-    addEmitter(stateEmitter) {
-      const clean = stateEmitter.subscribe(sub)
-      cleaners.push(clean)
-    },
-    id,
-    sub,
-  }
-
-  function asyncSub(resultValue: Promise<T>): Promise<T> | undefined {
-    const cancel = cancelablePromise<T>(resultValue, promiseData.controller)
-    promiseData.controller = cancel.controller
-    cancel.promise
-      ?.then((value) => {
-        cache.current = value
-        emitter.emit()
-      })
-      .catch((error) => {
-        if (isAbortError(error)) {
-          return
-        }
-        cache.current = error
-        emitter.emit()
-      })
-    return cancel.promise
-  }
-
-  const subscribe = function (): T {
-    const resultValue = context.run(ctx, anyFunction)
-
-    if (!isPromise(resultValue)) {
-      cache.current = resultValue
-      return resultValue
-    }
-
-    const promise = context.wrap(() => asyncSub(resultValue))()
-    if (isPromise(promise)) {
-      // we do not do anything with the promise, because it is already handled in asyncSub
-      promise.catch(() => null)
-    }
-    const promiseAsT = promise as T
-    cache.current = promiseAsT
-    return promiseAsT
-  }
-
-  subscribe.emitter = emitter
-  subscribe.destroy = function () {
-    for (const cleaner of cleaners) {
-      cleaner()
-    }
-    emitter.clear()
-    clearScheduler()
-  }
-  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)
-    })
-  }
-
-  if (process.env.NODE_ENV === 'development') {
-    let name: string | undefined
-    let type: StateType = 'derived'
-    if (isCreate(anyFunction)) {
-      type = 'state'
-      name = anyFunction.stateName
-    }
-
-    if (!name) {
-      name = anyFunction.name.length > 0 ? anyFunction.name : anyFunction.toString()
-    }
-
-    sendToDevelopmentTools({
-      name,
-      type,
-      value: subscribe(),
-      message: 'init',
-    })
-    const listener = developmentToolsListener(name, type)
-    subscribe.listen(listener)
-  }
-  subscribe.abort = function () {
-    if (promiseData.controller) {
-      promiseData.controller.abort()
-    }
-  }
-  return subscribe
-}

package/packages/core/types.ts

@@ -1,15 +0,0 @@
-// 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

@@ -1,57 +0,0 @@
-/* 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(() => {
-    return memo.destroy
-  }, [anyFunction, memo.destroy])
-
-  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

@@ -1,198 +0,0 @@
-/* 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__/sub-memo.test.ts

@@ -1,13 +0,0 @@
-/* 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/create-context.ts

@@ -1,60 +0,0 @@
-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/scheduler.ts

@@ -1,59 +0,0 @@
-export const THRESHOLD = 0.2
-export const THRESHOLD_ITEMS = 10
-export const RESCHEDULE_COUNT = 0
-
-export interface SchedulerOptions<T> {
-  readonly onResolveItem?: (item: T) => void
-  readonly onFinish: () => void
-}
-
-export function createScheduler<T>(options: SchedulerOptions<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
-}

package/packages/core/utils/sub-memo.ts

@@ -1,49 +0,0 @@
-import type { Subscribe } from '../subscriber'
-import { subscriber } from '../subscriber'
-import type { AnyFunction } from '../types'
-
-interface CacheItem<T extends AnyFunction> {
-  count: number
-  returnType: Subscribe<T>
-}
-
-const cache = new WeakMap<AnyFunction, CacheItem<AnyFunction>>()
-let cacheCount = 0
-
-export function getDebugCacheCreation() {
-  return cacheCount
-}
-function incrementDebugFunctionCreationCount() {
-  cacheCount++
-}
-
-export function subMemo<F extends AnyFunction>(anyFunction: F) {
-  cacheCount = 0
-  return {
-    call(): Subscribe<F> {
-      const item = cache.get(anyFunction)
-      if (item) {
-        item.count++
-
-        return item.returnType
-      }
-
-      incrementDebugFunctionCreationCount()
-      const returnType = subscriber(anyFunction)
-      const newItem = { count: 1, returnType }
-      cache.set(anyFunction, newItem)
-      return newItem.returnType
-    },
-    destroy() {
-      const item = cache.get(anyFunction)
-
-      if (item) {
-        item.count--
-        if (item.count === 0) {
-          item.returnType.destroy()
-          cache.delete(anyFunction)
-        }
-      }
-    },
-  }
-}

package/types/subscriber.d.ts

@@ -1,25 +0,0 @@
-import type { AnyFunction, Callable, Listener } from './types';
-import type { Emitter } from './utils/create-emitter';
-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 declare const context: {
-    run: <R>(ctxValue: SubscribeContext<unknown> | undefined, cb: () => R | Promise<R>) => R;
-    use: () => SubscribeContext<unknown> | undefined;
-    wrap: <X>(cb: () => X | Promise<X>) => () => X | Promise<X>;
-};
-export declare function subscriber<F extends AnyFunction, T extends ReturnType<F> = ReturnType<F>>(anyFunction: () => T): Subscribe<F, T>;
-export {};

package/types/use.d.ts

@@ -1,2 +0,0 @@
-import { type AnyFunction } from './types';
-export declare function use<F extends AnyFunction, T extends ReturnType<F>, S extends ReturnType<F>>(anyFunction: () => T, selector?: (stateValue: T) => S): undefined extends S ? T : S;

package/types/utils/create-context.d.ts

@@ -1,5 +0,0 @@
-export declare function createContext<T>(defaultContextValue: T): {
-    run: <R>(ctxValue: T, cb: () => R | Promise<R>) => R;
-    use: () => T | undefined;
-    wrap: <X>(cb: () => X | Promise<X>) => () => X | Promise<X>;
-};

package/types/utils/global-scheduler.d.ts

@@ -1,5 +0,0 @@
-import type { SchedulerOptions } from './scheduler';
-export declare function createGlobalScheduler(): {
-    add<T>(id: number, option: SchedulerOptions<T>): () => void;
-    schedule<T>(id: number, value: T): void;
-};

package/types/utils/sub-memo.d.ts

@@ -1,7 +0,0 @@
-import type { Subscribe } from '../subscriber';
-import type { AnyFunction } from '../types';
-export declare function getDebugCacheCreation(): number;
-export declare function subMemo<F extends AnyFunction>(anyFunction: F): {
-    call(): Subscribe<F>;
-    destroy(): void;
-};