muya 1.0.3 → 2.0.0-beta.1

package/packages/core/utils/scheduler.ts

@@ -0,0 +1,59 @@
+const THRESHOLD = 0.2
+const THRESHOLD_ITEMS = 10
+const RESCHEDULE_COUNT = 0
+
+interface Options<T> {
+  readonly onResolveItem?: (item: T) => void
+  readonly onFinish: () => void
+}
+
+export function createScheduler<T>(options: Options<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 → packages/core/utils}/shallow.ts

@@ -1,6 +1,6 @@
+/* eslint-disable sonarjs/cognitive-complexity */
 import { isArray, isMap, isSet } from './is'
 
-// eslint-disable-next-line sonarjs/cognitive-complexity
 export function shallow<T>(valueA: T, valueB: T): boolean {
   if (valueA == valueB) {
     return true
@@ -40,8 +40,8 @@ export function shallow<T>(valueA: T, valueB: T): boolean {
     return true
   }
 
-  const keysA = Object.keys(valueA as Record<string, unknown>)
-  const keysB = Object.keys(valueB as Record<string, unknown>)
+  const keysA = Object.keys(valueA)
+  const keysB = Object.keys(valueB)
   if (keysA.length !== keysB.length) return false
   for (const key of keysA) {
     if (

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

@@ -0,0 +1,37 @@
+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>>()
+
+export function subMemo<F extends AnyFunction>(anyFunction: F) {
+  return {
+    call(): Subscribe<F> {
+      const item = cache.get(anyFunction)
+      if (item) {
+        item.count++
+        return item.returnType
+      }
+      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/create.d.ts

@@ -1,21 +1,14 @@
-import type { SetterState, DefaultValue, IsEqual } from './types';
-/**
- * Creates a basic atom state.
- * @param defaultValue - The initial state value.
- * @param options - Optional settings for the state (e.g., isEqual, onSet).
- * @returns A state object that can be used as a hook and provides state management methods.
- * @example
- * ```typescript
- * // Global scope
- * const counterState = state(0);
- * const userState = state({ name: 'John', age: 20 });
- *
- * // React component
- * const counter = counterState(); // Use as a hook
- * const user = userState();
- *
- * // Access partial data from the state using slice
- * const userAge = userState.slice((state) => state.age)();
- * ```
- */
-export declare function create<T>(defaultValue: DefaultValue<T>, isEqual?: IsEqual<T>): SetterState<Awaited<T>>;
+import type { Emitter } from './utils/create-emitter';
+import type { Callable, DefaultValue, IsEqual, Listener, SetValue } from './types';
+interface RawState<T> {
+    (): T;
+    id: number;
+    set: (value: SetValue<T>) => void;
+    emitter: Emitter<T>;
+    listen: Listener<T>;
+}
+export type State<T> = {
+    readonly [K in keyof RawState<T>]: RawState<T>[K];
+} & Callable<T>;
+export declare function create<T>(initialValue: DefaultValue<T>, isEqual?: IsEqual<T>): State<T>;
+export {};

package/types/index.d.ts

@@ -1,6 +1,4 @@
 export * from './types';
 export { create } from './create';
-export { select } from './select';
-export { merge } from './merge';
-export { useStateValue } from './use-state-value';
-export { shallow } from './shallow';
+export { use } from './use';
+export { shallow } from './utils/shallow';

package/types/subscriber.d.ts

@@ -0,0 +1,25 @@
+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/types.d.ts

@@ -1,68 +1,12 @@
-import type { Emitter } from './create-emitter';
-/**
- * Equality check function.
- */
+export type AnyFunction = (...args: any[]) => any;
 export type IsEqual<T = unknown> = (a: T, b: T) => boolean;
-export type Setter<T> = (value: T) => T;
-/**
- * Set new state value function.
- */
-export type SetValue<T> = T | Setter<T>;
-export type UpdateValue<T> = T extends object ? Partial<T> : T;
-/**
- * Set new state function
- */
-export type StateValue<T, S> = undefined extends S ? T : S;
-export type Set<T> = (value: SetValue<T>) => void;
-export type Update<T> = (value: UpdateValue<T>) => void;
-/**
- * Getting state value function.
- */
-export type GetState<T> = () => T;
-export interface StateDataInternal<T = unknown> {
-    value?: T;
-    updateVersion: number;
-    abortController?: AbortController;
-}
-export declare enum StateKeys {
-    IS_STATE = "isState",
-    IS_SLICE = "isSlice"
-}
-export interface BaseState<T> {
-    /**
-     * Reset state to default value if it's basic atom - if it's family - it will clear all family members
-     */
-    reset: () => void;
-    /**
-     * Get current state value
-     */
-    getState: GetState<T>;
-    select: <S>(selector: (value: T) => S, isEqual?: IsEqual<S>) => GetterState<S>;
-    /**
-     * Internal state data
-     */
-    __internal: {
-        emitter: Emitter<T>;
-    };
-    subscribe: (listener: (value: T) => void) => () => void;
-}
-export interface GetterState<T> extends BaseState<T> {
-    <S>(selector?: (state: T) => S, isEqual?: IsEqual<S>): StateValue<T, S>;
-}
-export interface SetterState<T> extends GetterState<T> {
-    /**
-     * Set new state value
-     */
-    setState: Set<T>;
-    /**
-     * Set new state value
-     */
-    updateState: Update<T>;
-}
-export type State<T> = SetterState<T> | GetterState<T>;
+export type SetStateCb<T> = (value: T) => Awaited<T>;
+export type SetValue<T> = SetStateCb<T> | Awaited<T>;
 export type DefaultValue<T> = T | (() => T);
-export declare function getDefaultValue<T>(initValue: DefaultValue<T>): T;
-export interface Ref<T> {
-    current: T | undefined;
-    readonly isRef: true;
+export type Listener<T> = (listener: (value: T) => void) => () => void;
+export interface Cache<T> {
+    current?: T;
+    previous?: T;
 }
+export type Callable<T> = () => T;
+export declare const EMPTY_SELECTOR: <T>(stateValue: T) => T;

package/types/use.d.ts

@@ -0,0 +1,2 @@
+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/common.d.ts

@@ -0,0 +1,15 @@
+import type { Cache, IsEqual } from '../types';
+export declare 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 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;

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

@@ -0,0 +1,5 @@
+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/create-emitter.d.ts

@@ -0,0 +1,20 @@
+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 declare function createEmitter<T, P = undefined>(getSnapshot: () => T, getInitialSnapshot?: () => T): Emitter<T, P>;

package/types/{is.d.ts → utils/is.d.ts}

@@ -1,12 +1,11 @@
-import type { Ref, Setter, SetValue } from './types';
-export declare function isPromise(value: unknown): value is Promise<unknown>;
-export declare function isFunction(value: unknown): value is (...args: unknown[]) => unknown;
-export declare function isSetValueFunction<T>(value: SetValue<T>): value is Setter<T>;
-export declare function isObject(value: unknown): value is Record<string, unknown>;
-export declare function isRef<T>(value: unknown): value is Ref<T>;
+import type { SetStateCb, SetValue } 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>;
 export declare function isSet(value: unknown): value is Set<unknown>;
 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 isUndefined(value: unknown): value is undefined;

package/types/utils/scheduler.d.ts

@@ -0,0 +1,6 @@
+interface Options<T> {
+    readonly onResolveItem?: (item: T) => void;
+    readonly onFinish: () => void;
+}
+export declare function createScheduler<T>(options: Options<T>): (value: T) => void;
+export {};

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

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

package/esm/__tests__/common.test.js

@@ -1 +0,0 @@
-import{cancelablePromise as l,toType as m,useSyncExternalStore as r}from"../common";import{renderHook as s}from"@testing-library/react-hooks";import{createEmitter as n}from"../create-emitter";import{longPromise as i}from"./test-utils";describe("toType",()=>{it("should cast object to specified type",()=>{const t=m({a:1});expect(t.a).toBe(1)})}),describe("useSyncExternalStore",()=>{it("should return the initial state value",()=>{const e=n(()=>0),{result:t}=s(()=>r(e,o=>o));expect(t.current).toBe(0)}),it("should update when the state value changes",()=>{let e=0;const t=n(()=>e),{result:o}=s(()=>r(t,c=>c));e=1,t.emit(),expect(o.current).toBe(1)}),it("should use the selector function",()=>{let e=0;const t=n(()=>({count:e})),{result:o}=s(()=>r(t,c=>c.count));e=1,t.emit(),expect(o.current).toBe(1)}),it("should use the isEqual function",()=>{let e=0;const t=n(()=>({count:e})),o=jest.fn((u,a)=>u===a),{result:c}=s(()=>r(t,u=>u.count,o));e=1,t.emit(),expect(c.current).toBe(1),expect(o).toHaveBeenCalled()}),it("should test cancelable promise to abort",async()=>{const{promise:e,controller:t}=l(i(1e6));t.abort(),expect(e).rejects.toThrow("aborted")}),it("should test cancelable promise to resolve",async()=>{const{promise:e}=l(i(0));expect(await e).toBe(0)})});

package/esm/__tests__/is.test.js

@@ -1 +0,0 @@
-import{Abort as l}from"../common";import{isPromise as e,isFunction as r,isSetValueFunction as t,isObject as o,isRef as s,isMap as u,isSet as i,isArray as n,isEqualBase as a,isAbortError as f}from"../is";describe("isPromise",()=>{it("should return true for a Promise",()=>{expect(e(Promise.resolve())).toBe(!0)}),it("should return false for a non-Promise",()=>{expect(e(123)).toBe(!1)})}),describe("isFunction",()=>{it("should return true for a function",()=>{expect(r(()=>{})).toBe(!0)}),it("should return false for a non-function",()=>{expect(r(123)).toBe(!1)})}),describe("isSetValueFunction",()=>{it("should return true for a function",()=>{expect(t(()=>{})).toBe(!0)}),it("should return false for a non-function",()=>{expect(t(123)).toBe(!1)})}),describe("isObject",()=>{it("should return true for an object",()=>{expect(o({})).toBe(!0)}),it("should return false for a non-object",()=>{expect(o(123)).toBe(!1)})}),describe("isRef",()=>{it("should return true for a ref object",()=>{expect(s({isRef:!0})).toBe(!0)}),it("should return false for a non-ref object",()=>{expect(s({})).toBe(!1)})}),describe("isMap",()=>{it("should return true for a Map",()=>{expect(u(new Map)).toBe(!0)}),it("should return false for a non-Map",()=>{expect(u(123)).toBe(!1)})}),describe("isSet",()=>{it("should return true for a Set",()=>{expect(i(new Set)).toBe(!0)}),it("should return false for a non-Set",()=>{expect(i(123)).toBe(!1)})}),describe("isArray",()=>{it("should return true for an array",()=>{expect(n([])).toBe(!0)}),it("should return false for a non-array",()=>{expect(n(123)).toBe(!1)})}),describe("isEqualBase",()=>{it("should return true for equal values",()=>{expect(a(1,1)).toBe(!0)}),it("should return false for non-equal values",()=>{expect(a(1,2)).toBe(!1)})}),describe("isAbortError",()=>{it("should return true for an AbortError",()=>{expect(f(new DOMException("",l.Error))).toBe(!0)}),it("should return false for a non-AbortError",()=>{expect(f(new DOMException("","Error"))).toBe(!1)})});

package/esm/__tests__/merge.test.js

@@ -1 +0,0 @@
-import{create as t}from"../create";import{renderHook as i,act as x}from"@testing-library/react";import{merge as a}from"../merge";describe("merge",()=>{it("should test merge multiple-state",()=>{const o=t(1),c=t(1),n=t(3),u=a([o,c,n],(s,e,r)=>(expect(s).toBe(1),expect(e).toBe(1),expect(r).toBe(3),`${s} ${e} ${r}`)),p=i(()=>u());expect(p.result.current).toBe("1 1 3")}),it("should test merge multiple-state with isEqual",()=>{const o=t(1),c=t(1),n=t(3),u=a([o,c,n],(s,e,r)=>(expect(s).toBe(1),expect(e).toBe(1),expect(r).toBe(3),`${s} ${e} ${r}`),(s,e)=>s===e),p=i(()=>u());expect(p.result.current).toBe("1 1 3")}),it("should test merge multiple-state with different type",()=>{const o=t(1),c=t("1"),n=t({value:3}),u=t([1,2,3]),p=a([o,c,n,u],(e,r,l,m)=>(expect(e).toBe(1),expect(r).toBe("1"),expect(l).toStrictEqual({value:3}),expect(m).toStrictEqual([1,2,3]),`${e} ${r} ${l.value} ${m.join(" ")}`)),s=i(()=>p());expect(s.result.current).toBe("1 1 3 1 2 3")}),it("should test merge with reset",()=>{const o=t(1),c=t(1),n=t(3),u=a([o,c,n],(s,e,r)=>`${s} ${e} ${r}`),p=i(()=>u());x(()=>{o.setState(2),c.setState(2),n.setState(4)}),expect(p.result.current).toBe("2 2 4"),x(()=>{u.reset()}),expect(p.result.current).toBe("1 1 3")})});

package/esm/__tests__/types.test.js

@@ -1 +0,0 @@
-import{getDefaultValue as t}from"../types";describe("getDefaultValue",()=>{it("should return the value if it is not a function or promise",()=>{expect(t(123)).toBe(123)}),it("should return the resolved value if it is a function",()=>{expect(t(()=>123)).toBe(123)}),it("should return the promise if it is a promise",()=>{const e=Promise.resolve(123);expect(t(e)).toBe(e),expect(t(()=>e)).toBe(e)})});

package/esm/common.js

@@ -1 +0,0 @@
-import{useSyncExternalStoreWithSelector as c}from"use-sync-external-store/shim/with-selector";import{useDebugValue as i}from"react";function l(e){return e}function p(e,r,t){const o=c(e.subscribe,e.getSnapshot,e.getSnapshot,r?n=>r(n):l,t);return i(o),o}var u=(r=>(r.Error="StateAbortError",r))(u||{});function T(e,r){r&&r.abort();const t=new AbortController,{signal:o}=t;return{promise:new Promise((a,s)=>{o.addEventListener("abort",()=>{s(new DOMException("Promise was aborted","StateAbortError"))}),e.then(a).catch(s)}),controller:t}}export{u as Abort,T as cancelablePromise,l as toType,p as useSyncExternalStore};

package/esm/create-base-state.js

@@ -1 +0,0 @@
-import{select as m}from"./select";function p(a){const{emitter:r,getGetterState:o,reset:s,getState:e}=a;return{getState:e,reset:s,select(t,i){const n=o();return m(n,t,i)},__internal:{emitter:r},subscribe(t){return t(e()),r.subscribe(()=>{t(e())})}}}export{p as createBaseState};

package/esm/create-emitter.js

@@ -1 +0,0 @@
-function n(r){const t=new Set;return{subscribe:e=>(t.add(e),()=>{t.delete(e)}),emit:(...e)=>{for(const i of t)i(...e)},getSnapshot:r}}export{n as createEmitter};

package/esm/create-getter-state.js

@@ -1 +0,0 @@
-import{useStateValue as n}from"./use-state-value";function i(a){const{baseState:e}=a,t=(r,s)=>n(t,r,s);return t.__internal=e.__internal,t.getState=e.getState,t.reset=e.reset,t.select=e.select,t.subscribe=e.subscribe,t}export{i as createGetterState};

package/esm/is.js

@@ -1 +0,0 @@
-import{Abort as o}from"./common";function u(n){return n instanceof Promise}function i(n){return typeof n=="function"}function s(n){return typeof n=="function"}function t(n){return typeof n=="object"&&n!==null}function f(n){return t(n)&&n.isRef===!0}function c(n){return n instanceof Map}function a(n){return n instanceof Set}function p(n){return Array.isArray(n)}function k(n,r){return n===r?!0:!!Object.is(n,r)}function w(n){return n instanceof DOMException&&n.name===o.Error}function x(n){return n instanceof Error&&n.name!==o.Error}export{w as isAbortError,x as isAnyOtherError,p as isArray,k as isEqualBase,i as isFunction,c as isMap,t as isObject,u as isPromise,f as isRef,a as isSet,s as isSetValueFunction};

package/esm/merge.js

@@ -1 +0,0 @@
-import{createBaseState as s}from"./create-base-state";import{createEmitter as f}from"./create-emitter";import{createGetterState as u}from"./create-getter-state";import{isEqualBase as p}from"./is";function T(e,a,S=p){let r;const o=f(()=>{const t=a(...e.map(m=>m.getState()));return r!==void 0&&S(r,t)?r:(r=t,t)});for(const t of e)t.__internal.emitter.subscribe(()=>{o.emit()});const i=s({emitter:o,getGetterState:()=>n,getState:()=>a(...e.map(t=>t.getState())),reset(){for(const t of e)t.reset()}}),n=u({baseState:i});return n}export{T as merge};

package/esm/select.js

@@ -1 +0,0 @@
-import{createBaseState as m}from"./create-base-state";import{createEmitter as s}from"./create-emitter";import{createGetterState as u}from"./create-getter-state";import{isEqualBase as c}from"./is";function d(t,a,o=c){let e;const S=s(()=>{const r=a(t.getState());return e!==void 0&&o(e,r)?e:(e=r,r)});t.__internal.emitter.subscribe(()=>{S.emit()});const n=m({emitter:S,getGetterState:()=>i,getState:()=>a(t.getState()),reset:t.reset}),i=u({baseState:n});return i}export{d as select};

package/esm/shallow.js

@@ -1 +0,0 @@
-import{isArray as o,isMap as f,isSet as i}from"./is";function k(t,r){if(t==r)return!0;if(typeof t!="object"||t==null||typeof r!="object"||r==null)return!1;if(f(t)&&f(r)){if(t.size!==r.size)return!1;for(const[n,e]of t)if(!Object.is(e,r.get(n)))return!1;return!0}if(i(t)&&i(r)){if(t.size!==r.size)return!1;for(const n of t)if(!r.has(n))return!1;return!0}if(o(t)&&o(r)){if(t.length!==r.length)return!1;for(const[n,e]of t.entries())if(!Object.is(e,r[n]))return!1;return!0}const s=Object.keys(t),c=Object.keys(r);if(s.length!==c.length)return!1;for(const n of s)if(!Object.prototype.hasOwnProperty.call(r,n)||!Object.is(t[n],r[n]))return!1;return!0}export{k as shallow};

package/esm/use-state-value.js

@@ -1 +0,0 @@
-import{useSyncExternalStore as a,toType as i}from"./common";import{isAnyOtherError as s,isPromise as S}from"./is";function f(e,r=t=>i(t),o){const t=a(e.__internal.emitter,n=>r(n),o);if(S(t)||s(t))throw t;return t}export{f as useStateValue};

package/src/__tests__/common.test.ts

@@ -1,63 +0,0 @@
-import { cancelablePromise, toType, useSyncExternalStore } from '../common'
-import { renderHook } from '@testing-library/react-hooks'
-import { createEmitter } from '../create-emitter'
-import { longPromise } from './test-utils'
-
-describe('toType', () => {
-  it('should cast object to specified type', () => {
-    const object = { a: 1 }
-    const result = toType<{ a: number }>(object)
-    expect(result.a).toBe(1)
-  })
-})
-
-describe('useSyncExternalStore', () => {
-  it('should return the initial state value', () => {
-    const emitter = createEmitter(() => 0)
-    const { result } = renderHook(() => useSyncExternalStore(emitter, (state) => state))
-    expect(result.current).toBe(0)
-  })
-
-  it('should update when the state value changes', () => {
-    let value = 0
-    const emitter = createEmitter(() => value)
-    const { result } = renderHook(() => useSyncExternalStore(emitter, (state) => state))
-
-    value = 1
-    emitter.emit()
-    expect(result.current).toBe(1)
-  })
-
-  it('should use the selector function', () => {
-    let value = 0
-    const emitter = createEmitter(() => ({ count: value }))
-    const { result } = renderHook(() => useSyncExternalStore(emitter, (state: { count: number }) => state.count))
-
-    value = 1
-    emitter.emit()
-    expect(result.current).toBe(1)
-  })
-
-  it('should use the isEqual function', () => {
-    let value = 0
-    const emitter = createEmitter(() => ({ count: value }))
-    const isEqual = jest.fn((a, b) => a === b)
-    const { result } = renderHook(() => useSyncExternalStore(emitter, (state: { count: number }) => state.count, isEqual))
-
-    value = 1
-    emitter.emit()
-    expect(result.current).toBe(1)
-    expect(isEqual).toHaveBeenCalled()
-  })
-
-  it('should test cancelable promise to abort', async () => {
-    const { promise, controller } = cancelablePromise(longPromise(1000 * 1000))
-    controller.abort()
-    expect(promise).rejects.toThrow('aborted')
-  })
-
-  it('should test cancelable promise to resolve', async () => {
-    const { promise } = cancelablePromise(longPromise(0))
-    expect(await promise).toBe(0)
-  })
-})

package/src/__tests__/create.test.tsx

@@ -1,84 +0,0 @@
-import { Suspense } from 'react'
-import { create } from '../create'
-import { renderHook, waitFor, act, render } from '@testing-library/react'
-import { ErrorBoundary, longPromise } from './test-utils'
-
-describe('create', () => {
-  it('should create test with base value', () => {
-    const state = create(0)
-    const result = renderHook(() => state())
-    expect(result.result.current).toBe(0)
-  })
-  it('should create test with function', () => {
-    const state = create(() => 0)
-    const result = renderHook(() => state())
-    expect(result.result.current).toBe(0)
-  })
-  it('should create test with promise', async () => {
-    const state = create(Promise.resolve(0))
-    const result = renderHook(() => state())
-    await waitFor(() => {
-      expect(result.result.current).toBe(0)
-    })
-  })
-  it('should create test with promise and wait to be resolved', async () => {
-    const state = create(longPromise)
-    const result = renderHook(() => state(), { wrapper: ({ children }) => <Suspense fallback={null}>{children}</Suspense> })
-
-    await waitFor(() => {
-      expect(result.result.current).toBe(0)
-    })
-  })
-  it('should create test with lazy promise and wait to be resolved', async () => {
-    const state = create(async () => await longPromise())
-    const result = renderHook(() => state(), { wrapper: ({ children }) => <Suspense fallback={null}>{children}</Suspense> })
-
-    await waitFor(() => {
-      expect(result.result.current).toBe(0)
-    })
-  })
-  it('should create test with promise and set value during the promise is pending', async () => {
-    const state = create(longPromise)
-    const result = renderHook(() => state(), { wrapper: ({ children }) => <Suspense fallback={null}>{children}</Suspense> })
-
-    act(() => {
-      state.setState(10)
-    })
-    await waitFor(() => {
-      expect(result.result.current).toBe(10)
-    })
-  })
-
-  it('should create test with lazy promise and set value during the promise is pending', async () => {
-    const state = create(async () => await longPromise())
-    const result = renderHook(() => state(), { wrapper: ({ children }) => <Suspense fallback={null}>{children}</Suspense> })
-
-    act(() => {
-      state.setState(10)
-    })
-    await waitFor(() => {
-      expect(result.result.current).toBe(10)
-    })
-  })
-
-  it('should fail inside the hook when the promise is rejected with not abort isWithError', async () => {
-    const state = create(Promise.reject('error-message'))
-
-    function Component() {
-      state()
-      return null
-    }
-
-    const result = render(
-      <ErrorBoundary fallback={<div>An error occurred.</div>}>
-        <Suspense fallback={'suspense-error'}>
-          <Component />
-        </Suspense>
-      </ErrorBoundary>,
-    )
-
-    await waitFor(() => {
-      expect(result.container.textContent).toBe('An error occurred.')
-    })
-  })
-})

package/src/__tests__/merge.test.ts

@@ -1,78 +0,0 @@
-import { create } from '../create'
-import { renderHook, act } from '@testing-library/react'
-import { merge } from '../merge'
-
-describe('merge', () => {
-  it('should test merge multiple-state', () => {
-    const state1 = create(1)
-    const state2 = create(1)
-    const state3 = create(3)
-
-    const useMerged = merge([state1, state2, state3], (value1, value2, value3) => {
-      expect(value1).toBe(1)
-      expect(value2).toBe(1)
-      expect(value3).toBe(3)
-      return `${value1} ${value2} ${value3}`
-    })
-    const result = renderHook(() => useMerged())
-    expect(result.result.current).toBe('1 1 3')
-  })
-
-  it('should test merge multiple-state with isEqual', () => {
-    const state1 = create(1)
-    const state2 = create(1)
-    const state3 = create(3)
-
-    const useMerged = merge(
-      [state1, state2, state3],
-      (value1, value2, value3) => {
-        expect(value1).toBe(1)
-        expect(value2).toBe(1)
-        expect(value3).toBe(3)
-        return `${value1} ${value2} ${value3}`
-      },
-      (a, b) => a === b,
-    )
-    const result = renderHook(() => useMerged())
-    expect(result.result.current).toBe('1 1 3')
-  })
-
-  it('should test merge multiple-state with different type', () => {
-    const state1 = create(1)
-    const state2 = create('1')
-    const state3 = create({ value: 3 })
-    const state4 = create([1, 2, 3])
-
-    const useMerged = merge([state1, state2, state3, state4], (value1, value2, value3, value4) => {
-      expect(value1).toBe(1)
-      expect(value2).toBe('1')
-      expect(value3).toStrictEqual({ value: 3 })
-      expect(value4).toStrictEqual([1, 2, 3])
-      return `${value1} ${value2} ${value3.value} ${value4.join(' ')}`
-    })
-    const result = renderHook(() => useMerged())
-    expect(result.result.current).toBe('1 1 3 1 2 3')
-  })
-  it('should test merge with reset', () => {
-    const state1 = create(1)
-    const state2 = create(1)
-    const state3 = create(3)
-
-    const useMerged = merge([state1, state2, state3], (value1, value2, value3) => {
-      return `${value1} ${value2} ${value3}`
-    })
-    const result = renderHook(() => useMerged())
-
-    act(() => {
-      state1.setState(2)
-      state2.setState(2)
-      state3.setState(4)
-    })
-    expect(result.result.current).toBe('2 2 4')
-
-    act(() => {
-      useMerged.reset()
-    })
-    expect(result.result.current).toBe('1 1 3')
-  })
-})