muya 2.0.0-beta.3 → 2.0.1

package/src/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/src/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/src/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/src/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/src/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;
-};