muya 2.0.0-beta.3 → 2.0.0

package/types/use-value.d.ts

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

package/types/utils/common.d.ts

@@ -3,13 +3,14 @@ export declare enum Abort {
     Error = "StateAbortError"
 }
 export interface CancelablePromise<T> {
-    promise?: Promise<T>;
+    promise: Promise<T>;
     controller?: AbortController;
-    resolveInitialPromise?: (value: T) => void;
 }
 /**
- * Cancelable promise function, return promise and controller
+ * Check if the cache value is different from the previous value.
  */
-export declare function cancelablePromise<T>(promise: Promise<T>, previousController?: AbortController): CancelablePromise<T>;
-export declare function generateId(): number;
 export declare function canUpdate<T>(cache: Cache<T>, isEqual?: IsEqual<T>): boolean;
+/**
+ * Handle async updates for `create` and `select`
+ */
+export declare function handleAsyncUpdate<T>(cache: Cache<T>, emit: () => void, value: T): T;

package/types/utils/is.d.ts

@@ -1,5 +1,4 @@
-import type { SetStateCb, SetValue } from '../types';
-import type { State } from '../create';
+import type { SetStateCb, SetValue, State } from '../types';
 export declare function isPromise<T>(value: unknown): value is Promise<T>;
 export declare function isFunction<T extends (...args: unknown[]) => unknown>(value: unknown): value is T;
 export declare function isMap(value: unknown): value is Map<unknown, unknown>;
@@ -8,6 +7,6 @@ export declare function isArray(value: unknown): value is Array<unknown>;
 export declare function isEqualBase<T>(valueA: T, valueB: T): boolean;
 export declare function isSetValueFunction<T>(value: SetValue<T>): value is SetStateCb<T>;
 export declare function isAbortError(value: unknown): value is DOMException;
-export declare function isAnyOtherError(value: unknown): value is Error;
+export declare function isError(value: unknown): value is Error;
 export declare function isUndefined(value: unknown): value is undefined;
-export declare function isCreate(value: unknown): value is State<unknown>;
+export declare function isState<T>(value: unknown): value is State<T>;

package/esm/__tests__/create-async.test.js

@@ -1 +0,0 @@
-import{create as r}from"../create";import{waitFor as c}from"@testing-library/react";import{longPromise as m}from"./test-utils";import{isPromise as u}from"../utils/is";import{subscriber as n}from"../subscriber";describe("create",()=>{it("should subscribe to context and notified it with parameters",async()=>{const t=r(1),i=r(2);function s(){return t()+i()}async function a(p){return t()+i()+s()+p}let o=0;const e=n(()=>a(10));expect(u(e.emitter.getSnapshot())).toBe(!0),e.listen(async()=>{o++}),expect(o).toBe(0),expect(await e()).toBe(16),t.set(2),await c(async()=>{}),expect(await e()).toBe(18),expect(o).toBe(4)}),it("should async subscribe to context and notified it",async()=>{const t=r(1),i=r(Promise.resolve(2));async function s(){return await m(),t()+await i()}async function a(){return t()+await i()+await s()}let o=0;const e=n(a);e.listen(()=>{o++}),e(),expect(t.emitter.getSize()).toBe(1),expect(i.emitter.getSize()).toBe(1),expect(e.emitter.getSize()).toBe(1),t.set(2),await c(async()=>{expect(await e()).toBe(8),expect(o).toBe(5)}),i.set(3),await c(async()=>{expect(await e()).toBe(10),expect(o).toBe(10)}),expect(t.emitter.getSize()).toBe(1),expect(i.emitter.getSize()).toBe(1),expect(e.emitter.getSize()).toBe(1),e.destroy(),expect(t.emitter.getSize()).toBe(0),expect(i.emitter.getSize()).toBe(0),expect(e.emitter.getSize()).toBe(0)})});

package/esm/subscriber.js

@@ -1 +0,0 @@
-import{cancelablePromise as F,canUpdate as v,generateId as h}from"./utils/common";import{createContext as x}from"./utils/create-context";import{createEmitter as S}from"./utils/create-emitter";import"./debug/development-tools";import{createGlobalScheduler as C}from"./utils/global-scheduler";import{isAbortError as E,isEqualBase as R,isPromise as m,isUndefined as w}from"./utils/is";const d=C(),b=x(void 0);function U(p){const r={};let u=!1;const a=[],i={},s=S(()=>u?r.current:(u=!0,n()),()=>(u=!0,n()));async function l(){v(r,R)&&(i.controller&&i.controller.abort(),d.schedule(c,null))}const c=h(),f=d.add(c,{onFinish(){r.current=n(),s.emit()}}),T={addEmitter(e){const t=e.subscribe(l);a.push(t)},id:c,sub:l};function y(e){const t=F(e,i.controller);return i.controller=t.controller,t.promise?.then(o=>{r.current=o,s.emit()}).catch(o=>{E(o)||(r.current=o,s.emit())}),t.promise}const n=function(){const e=b.run(T,p);if(!m(e))return r.current=e,e;const t=b.wrap(()=>y(e))();m(t)&&t.catch(()=>null);const o=t;return r.current=o,o};return n.emitter=s,n.destroy=function(){for(const e of a)e();s.clear(),f()},n.id=c,n.listen=function(e){return s.subscribe(()=>{const t=r.current;if(w(t))throw new Error("The value is undefined");e(t)})},n.abort=function(){i.controller&&i.controller.abort()},n}export{b as context,U as subscriber};

package/esm/use.js

@@ -1 +0,0 @@
-import{useDebugValue as u,useEffect as s,useRef as m}from"react";import{EMPTY_SELECTOR as a}from"./types";import{isAnyOtherError as c,isPromise as T}from"./utils/is";import{useSyncExternalStore as d}from"react";import{subMemo as p}from"./utils/sub-memo";const f=10,E=3;function R(t){const e=m({renders:0,startTime:performance.now()});s(()=>{e.current.renders++,!(performance.now()-e.current.startTime<f)&&(e.current.renders<E||(e.current.startTime=performance.now(),e.current.renders=0,console.warn(`Function ${t.name.length>0?t.name:t} seems to be not memoized, wrap the function to the useCallback or use global defined functions.`)))},[t])}function b(t,e=a){const n=p(t),o=n.call(),i=o.emitter.getInitialSnapshot??o.emitter.getSnapshot;s(()=>n.destroy,[t,n.destroy]);const r=d(o.emitter.subscribe,()=>e(o.emitter.getSnapshot()),()=>e(i()));if(u(r),T(r))throw r;if(c(r))throw n.destroy(),r;return r}export{b as use};

package/esm/utils/__tests__/context.test.js

@@ -1 +0,0 @@
-import{createContext as c}from"../create-context";import{longPromise as r}from"../../__tests__/test-utils";describe("context",()=>{it("should check context",()=>{const e=c({name:"John Doe"}),t=()=>{e.run({name:"Jane Doe"},()=>{expect(e.use()).toEqual({name:"Jane Doe"})})};expect(e.use()).toEqual({name:"John Doe"}),t(),expect(e.use()).toEqual({name:"John Doe"})}),it("should test async context",e=>{const t=c("empty"),o=async()=>new Promise(u=>setTimeout(u,10));t.run("outer",()=>{expect(t.use()).toEqual("outer"),setTimeout(t.wrap(async()=>{try{await o(),expect(t.use()).toEqual("outer"),s()}catch(u){e(u)}}),10),t.run("inner",()=>{expect(t.use()).toEqual("inner"),setTimeout(t.wrap(()=>{try{expect(t.use()).toEqual("inner"),s()}catch(u){e(u)}}),10)}),expect(t.use()).toEqual("outer")});let n=0;function s(){n+=1,n===2&&e()}}),it("should test async nested context",e=>{const t=c(0);t.run(1,()=>{expect(t.use()).toEqual(1),t.run(2,()=>{t.run(3,()=>{expect(t.use()).toEqual(3),setTimeout(t.wrap(()=>{expect(t.use()).toEqual(3)}),10),expect(t.use()).toEqual(3)}),setTimeout(t.wrap(()=>{expect(t.use()).toEqual(2)}),10),expect(t.use()).toEqual(2),t.run(3,()=>{expect(t.use()).toEqual(3),setTimeout(t.wrap(()=>{expect(t.use()).toEqual(3),t.run(4,()=>{expect(t.use()).toEqual(4),setTimeout(t.wrap(()=>{expect(t.use()).toEqual(4),e()}),10),expect(t.use()).toEqual(4)})}),10),expect(t.use()).toEqual(3)}),expect(t.use()).toEqual(2)}),expect(t.use()).toEqual(1)}),expect(t.use()).toEqual(0)}),it("should stress test context with async random code",async()=>{const t=c(0);for(let n=0;n<1e4;n++)t.run(n,()=>{expect(t.use()).toEqual(n)});const o=[];for(let n=0;n<1e4;n++)t.run(n,()=>{expect(t.use()).toEqual(n);const s=new Promise(u=>{setTimeout(t.wrap(()=>{expect(t.use()).toEqual(n),u(n)}),Math.random()*100)});o.push(s)});await Promise.all(o)}),it("should-test-default-value-with-ctx",async()=>{const e=c({counter:1});e.run({counter:10},async()=>{await r(10),expect(e.use()?.counter).toBe(10)}),e.run({counter:12},()=>{expect(e.use()?.counter).toBe(12)})}),it("should test nested context",()=>{const t=c({count:0});function o(){const n=t.use();expect(n?.count).toBe(0),t.run({count:1},()=>{const s=t.use();expect(s?.count).toBe(1),t.run({count:2},()=>{const u=t.use();expect(u?.count).toBe(2)})})}o(),o()}),it("should test nested context with async when promise is returned, but not waited",async()=>{const e=c({count:0});async function t(){await r(10);const n=e.use();expect(n?.count).toBe(1)}async function o(){await t(),e.wrap(t);const n=e.use();expect(n?.count).toBe(1)}e.run({count:1},o)})});

package/esm/utils/__tests__/sub-memo.test.js

@@ -1 +0,0 @@
-import{subMemo as t}from"../sub-memo";describe("memo-fn",()=>{it("should create memo fn",()=>{function e(){return!0}const o=t(e);expect(o.call().emitter).toBeDefined()})});

package/esm/utils/create-context.js

@@ -1 +0,0 @@
-import{isPromise as i}from"./is";const a=Symbol("_");function f(s){const t=[];function o(){if(t.length===0)return s;const e=t.at(-1);return e===a?s:e}function u(e,n){t.push(e);const r=n();return i(r)?(async()=>{try{return await r}finally{t.pop()}})():(t.pop(),r)}function c(e){const n=o();return()=>{t.push(n);const r=e();return i(r)?(async()=>{try{return await r}finally{t.pop()}})():(t.pop(),r)}}return{run:u,use:o,wrap:c}}export{f as createContext};

package/esm/utils/global-scheduler.js

@@ -1 +0,0 @@
-import{RESCHEDULE_COUNT as l,THRESHOLD as f,THRESHOLD_ITEMS as d}from"./scheduler";function m(){const t=new Map,r=new Set;let s=performance.now(),u=!1;function c(){const n=performance.now(),e=n-s,{size:o}=r;if(e<f&&o>0&&o<d){s=n,i();return}u||(u=!0,Promise.resolve().then(()=>{u=!1,s=performance.now(),i()}))}function i(){if(r.size===0)return;const n=new Set;for(const e of r){if(t.has(e.id)){n.add(e.id);const{onResolveItem:o}=t.get(e.id);o&&o(e.value)}r.delete(e)}if(r.size>l){c();return}for(const e of n)t.get(e)?.onFinish()}return{add(n,e){return t.set(n,e),()=>{t.delete(n)}},schedule(n,e){r.add({value:e,id:n}),c()}}}export{m as createGlobalScheduler};

package/esm/utils/scheduler.js

@@ -1 +0,0 @@
-const d=.2,T=10,S=0;function E(f){const n=new Set,{onResolveItem:r,onFinish:a}=f;let o=performance.now(),t=!1;function s(){const e=performance.now(),u=e-o,{size:c}=n;if(u<.2&&c>0&&c<10){o=e,i();return}t||(t=!0,Promise.resolve().then(()=>{t=!1,o=performance.now(),i()}))}function i(){if(n.size!==0){for(const e of n)r&&r(e),n.delete(e);if(n.size>0){s();return}a()}}function l(e){n.add(e),s()}return l}export{S as RESCHEDULE_COUNT,d as THRESHOLD,T as THRESHOLD_ITEMS,E as createScheduler};

package/esm/utils/sub-memo.js

@@ -1 +0,0 @@
-import{subscriber as c}from"../subscriber";const n=new WeakMap;let r=0;function p(){return r}function o(){r++}function b(t){return r=0,{call(){const e=n.get(t);if(e)return e.count++,e.returnType;o();const u={count:1,returnType:c(t)};return n.set(t,u),u.returnType},destroy(){const e=n.get(t);e&&(e.count--,e.count===0&&(e.returnType.destroy(),n.delete(t)))}}}export{p as getDebugCacheCreation,b as subMemo};

package/src/__tests__/create-async.test.ts

@@ -1,88 +0,0 @@
-import { create } from '../create'
-import { waitFor } from '@testing-library/react'
-import { longPromise } from './test-utils'
-import { isPromise } from '../utils/is'
-import { subscriber } from '../subscriber'
-
-describe('create', () => {
-  it('should subscribe to context and notified it with parameters', async () => {
-    const state1 = create(1)
-    const state2 = create(2)
-
-    function derivedNested() {
-      return state1() + state2()
-    }
-    async function derived(plus: number) {
-      return state1() + state2() + derivedNested() + plus
-    }
-
-    let updatesCounter = 0
-    const sub = subscriber(() => derived(10))
-    expect(isPromise(sub.emitter.getSnapshot())).toBe(true)
-    sub.listen(async () => {
-      updatesCounter++
-    })
-    expect(updatesCounter).toBe(0)
-    // check if there is not maximum call stack
-    expect(await sub()).toBe(16)
-
-    state1.set(2)
-    //
-    await waitFor(async () => {})
-    expect(await sub()).toBe(18)
-
-    expect(updatesCounter).toBe(4)
-  })
-
-  it('should async subscribe to context and notified it', async () => {
-    const state1 = create(1)
-    const state2 = create(Promise.resolve(2))
-
-    async function derivedNested() {
-      await longPromise()
-      return state1() + (await state2())
-    }
-    async function derived() {
-      return state1() + (await state2()) + (await derivedNested())
-    }
-
-    let updatesCounter = 0
-
-    const sub = subscriber(derived)
-
-    sub.listen(() => {
-      updatesCounter++
-    })
-
-    // check if there is not maximum call stack
-    sub()
-
-    // check if not assigned multiple times, but only once
-    expect(state1.emitter.getSize()).toBe(1)
-    expect(state2.emitter.getSize()).toBe(1)
-    expect(sub.emitter.getSize()).toBe(1)
-    state1.set(2)
-
-    await waitFor(async () => {
-      expect(await sub()).toBe(8)
-      expect(updatesCounter).toBe(5)
-    })
-
-    state2.set(3)
-
-    await waitFor(async () => {
-      expect(await sub()).toBe(10)
-      expect(updatesCounter).toBe(10)
-    })
-
-    expect(state1.emitter.getSize()).toBe(1)
-    expect(state2.emitter.getSize()).toBe(1)
-    expect(sub.emitter.getSize()).toBe(1)
-
-    sub.destroy()
-
-    expect(state1.emitter.getSize()).toBe(0)
-    expect(state2.emitter.getSize()).toBe(0)
-    expect(sub.emitter.getSize()).toBe(0)
-  })
-})

package/src/__tests__/subscriber.test.tsx

@@ -1,89 +0,0 @@
-import { waitFor } from '@testing-library/react'
-import { create } from '../create'
-import { subscriber } from '../subscriber'
-import { longPromise } from './test-utils'
-
-describe('subscriber', () => {
-  it('should test subscriber and cleaning the emitters', () => {
-    const state1 = create(1)
-    const sub = subscriber(state1)
-    // at this point, the emitter is not subscribed yet, as it need to be called first.
-    expect(state1.emitter.getSize()).toBe(0)
-
-    // check if the value is correct
-    expect(sub()).toBe(1)
-
-    // now we can check if the value is subscribed
-    expect(state1.emitter.getSize()).toBe(1)
-    // we destroy the subscriber, meaning that the emitter should be cleaned
-
-    sub.destroy()
-
-    expect(state1.emitter.getSize()).toBe(0)
-
-    // and test re-aligning the subscriber
-    expect(sub()).toBe(1)
-    expect(state1.emitter.getSize()).toBe(1)
-  })
-  it('should test how many events are emitter via singleton state', async () => {
-    const state1 = create(1)
-    const sub = subscriber(state1)
-
-    let updateCount = 0
-
-    sub.listen(() => {
-      updateCount++
-    })
-    sub()
-    await waitFor(() => {})
-    // we do not received initial value as it is not changed
-    expect(updateCount).toBe(0)
-
-    state1.set(2)
-    await waitFor(() => {})
-    expect(updateCount).toBe(1)
-  })
-  it('should test how many events are emitter via singleton async state', async () => {
-    const state1 = create(longPromise())
-    const sub = subscriber(state1)
-
-    let updateCount = 0
-
-    sub.listen(() => {
-      updateCount++
-    })
-    sub()
-    await waitFor(() => {})
-    // we do not received initial value as it is not changed
-    expect(updateCount).toBe(0)
-
-    state1.set(2)
-    await waitFor(() => {})
-    expect(updateCount).toBe(1)
-  })
-
-  it('should test how many events are emitter via derived state', async () => {
-    const state1 = create(longPromise())
-
-    async function derived() {
-      //   await longPromise()
-      return await state1()
-    }
-    const sub = subscriber(derived)
-
-    let updateCount = 0
-
-    sub.listen(() => {
-      updateCount++
-    })
-    await sub()
-    await waitFor(() => {})
-    expect(await sub()).toBe(0)
-    // // we do not received initial value as it is not changed
-    expect(updateCount).toBe(2)
-
-    // state1.set(2)
-    // await waitFor(() => {})
-    // expect(updateCount).toBe(1)
-  })
-})

package/src/__tests__/use-async.test.tsx

@@ -1,45 +0,0 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-import { renderHook } from '@testing-library/react-hooks'
-import { create } from '../create'
-import { use } from '../use'
-import { Suspense } from 'react'
-import { waitFor } from '@testing-library/react'
-
-describe('use-create', () => {
-  const reRendersBefore = jest.fn()
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  it('should test sub hook', async () => {
-    const userState = create({ name: 'John', age: 30 })
-    async function getDataWithUser() {
-      const result = await fetch('https://jsonplaceholder.typicode.com/todos/1')
-      const json = await result.json()
-      return { age: userState().age, ...json }
-    }
-
-    const suspenseFunction = jest.fn()
-    function Loading() {
-      suspenseFunction()
-      return <div>Loading...</div>
-    }
-
-    const { result } = renderHook(
-      () => {
-        reRendersBefore()
-        const data = use(getDataWithUser)
-        return data
-      },
-      // @ts-expect-error
-      { wrapper: ({ children }) => <Suspense fallback={<Loading />}>{children}</Suspense> },
-    )
-
-    await waitFor(() => {
-      expect(result.current).toEqual({ userId: 1, id: 1, title: 'delectus aut autem', completed: false, age: 30 })
-    })
-    expect(suspenseFunction).toHaveBeenCalledTimes(1)
-    expect(result.current).toEqual({ userId: 1, id: 1, title: 'delectus aut autem', completed: false, age: 30 })
-  })
-})

package/src/__tests__/use.test.tsx

@@ -1,125 +0,0 @@
-import { act, renderHook } from '@testing-library/react-hooks'
-import { create } from '../create'
-import { use } from '../use'
-import { waitFor } from '@testing-library/react'
-import { useCallback } from 'react'
-import { getDebugCacheCreation } from '../utils/sub-memo'
-
-describe('use-create', () => {
-  const reRendersBefore = jest.fn()
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  it('should test use hook', async () => {
-    const state = create(1)
-
-    const { result } = renderHook(() => {
-      reRendersBefore()
-      return use(state)
-    })
-
-    state.set(2)
-
-    await waitFor(() => {})
-    expect(result.current).toBe(2)
-    expect(reRendersBefore).toHaveBeenCalledTimes(2)
-
-    state.set(3)
-
-    await waitFor(() => {})
-    expect(result.current).toBe(3)
-    expect(reRendersBefore).toHaveBeenCalledTimes(3)
-  })
-
-  it('should test derived state with multiple states', async () => {
-    const state1 = create(1)
-    const state2 = create(2)
-
-    function derivedBefore(plusValue: number) {
-      return state1() + state2() + plusValue
-    }
-
-    function derived() {
-      return state1() + state2() + derivedBefore(10)
-    }
-
-    const { result } = renderHook(() => {
-      reRendersBefore()
-      return use(derived)
-    })
-
-    await waitFor(() => {})
-    expect(reRendersBefore).toHaveBeenCalledTimes(1)
-    act(() => {
-      state1.set(2)
-      state2.set(3)
-    })
-
-    await waitFor(() => {})
-    expect(result.current).toBe(20)
-    expect(reRendersBefore).toHaveBeenCalledTimes(2)
-  })
-
-  it('should test use hook without memoize fn', async () => {
-    const state1 = create(1)
-    const state2 = create(2)
-
-    function derivedBefore(plusValue: number) {
-      return state1() + state2() + plusValue
-    }
-
-    function derived(add: number) {
-      return state1() + state2() + derivedBefore(add)
-    }
-
-    const { result } = renderHook(() => {
-      reRendersBefore()
-      return use(() => derived(10))
-    })
-    expect(getDebugCacheCreation()).toBe(1)
-
-    await waitFor(() => {})
-    expect(reRendersBefore).toHaveBeenCalledTimes(1)
-    act(() => {
-      state1.set(2)
-      state2.set(3)
-    })
-    expect(getDebugCacheCreation()).toBe(1)
-    await waitFor(() => {})
-    expect(result.current).toBe(20)
-    expect(reRendersBefore).toHaveBeenCalledTimes(2)
-  })
-
-  it('should test use hook with memoize fn', async () => {
-    const state1 = create(1)
-    const state2 = create(2)
-
-    function derivedBefore(plusValue: number) {
-      return state1() + state2() + plusValue
-    }
-
-    function derived(add: number) {
-      return state1() + state2() + derivedBefore(add)
-    }
-
-    const { result } = renderHook(() => {
-      reRendersBefore()
-      const memoized = useCallback(() => derived(10), [])
-      return use(memoized)
-    })
-    expect(getDebugCacheCreation()).toBe(1)
-
-    await waitFor(() => {})
-    expect(reRendersBefore).toHaveBeenCalledTimes(1)
-    act(() => {
-      state1.set(2)
-      state2.set(3)
-    })
-    expect(getDebugCacheCreation()).toBe(1)
-    await waitFor(() => {})
-    expect(result.current).toBe(20)
-    expect(reRendersBefore).toHaveBeenCalledTimes(2)
-  })
-})

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