muya 1.1.0 → 2.0.0-beta.1

package/{src → packages/core/utils}/shallow.ts

@@ -1,13 +1,10 @@
+/* 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
   }
-  if (Object.is(valueA, valueB)) {
-    return true
-  }
 
   if (typeof valueA !== 'object' || valueA == null || typeof valueB !== 'object' || valueB == null) {
     return false
@@ -43,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/__tests__/test-utils.d.ts

@@ -0,0 +1,20 @@
+import { Component } from 'react';
+export declare function longPromise(time?: number): Promise<number>;
+export declare class ErrorBoundary extends Component<{
+    fallback: React.ReactNode;
+    children: React.ReactNode;
+}, {
+    hasError: boolean;
+    error: Error | null;
+}> {
+    constructor(props: {
+        fallback: React.ReactNode;
+        children: React.ReactNode;
+    });
+    static getDerivedStateFromError(error: Error): {
+        hasError: boolean;
+        error: Error;
+    };
+    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+    render(): import("react").ReactNode;
+}

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;
-}
-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>;
-    merge: <T2, S>(state2: GetterState<T2>, selector: (value1: T, value2: T2) => 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/utils/is.d.ts

@@ -0,0 +1,11 @@
+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/common.js

@@ -1 +0,0 @@
-import{useSyncExternalStoreWithSelector as u}from"use-sync-external-store/shim/with-selector";import{useDebugValue as s}from"react";function S(e){return e}function i(e,t,r){const n=u(e.subscribe,e.getSnapshot,e.getSnapshot,t?o=>t(o):S,r);return s(n),n}export{S as toType,i as useSyncExternalStore};

package/esm/create-base-state.js

@@ -1 +0,0 @@
-import{merge as c}from"./merge";import{select as p}from"./select";function y(n){const{emitter:o,getGetterState:s,reset:i,getState:e}=n;return{getState:e,reset:i,select(t,r){const a=s();return p(a,t,r)},merge(t,r,a){const m=s();return c(m,t,r,a)},__internal:{emitter:o},subscribe(t){return t(e()),o.subscribe(()=>{t(e())})}}}export{y 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(r){const{baseState:t}=r,e=(a,s)=>n(e,a,s);return e.__internal=t.__internal,e.getState=t.getState,e.reset=t.reset,e.select=t.select,e.merge=t.merge,e.subscribe=t.subscribe,e}export{i as createGetterState};

package/esm/is.js

@@ -1 +0,0 @@
-function o(n){return n instanceof Promise}function r(n){return typeof n=="function"}function u(n){return typeof n=="function"}function t(n){return typeof n=="object"&&n!==null}function i(n){return t(n)&&n.isRef===!0}function s(n){return n instanceof Map}function f(n){return n instanceof Set}function a(n){return Array.isArray(n)}function c(n,e){return n===e?!0:!!Object.is(n,e)}export{a as isArray,c as isEqualBase,r as isFunction,s as isMap,t as isObject,o as isPromise,i as isRef,f as isSet,u as isSetValueFunction};

package/esm/merge.js

@@ -1 +0,0 @@
-import{createBaseState as u}from"./create-base-state";import{createEmitter as s}from"./create-emitter";import{createGetterState as c}from"./create-getter-state";import{isEqualBase as f}from"./is";function T(t,e,i,n=f){let r;const a=s(()=>{const S=i(t.getState(),e.getState());return r!==void 0&&n(r,S)?r:(r=S,S)});t.__internal.emitter.subscribe(()=>{a.emit()}),e.__internal.emitter.subscribe(()=>{a.emit()});const o=u({emitter:a,getGetterState:()=>m,getState:()=>i(t.getState(),e.getState()),reset(){t.reset(),e.reset()}}),m=c({baseState:o});return m}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 b(t,r){if(t==r||Object.is(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{b as shallow};

package/esm/use-state-value.js

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

package/src/common.ts

@@ -1,28 +0,0 @@
-import { useSyncExternalStoreWithSelector as useSync } from 'use-sync-external-store/shim/with-selector'
-import type { Emitter } from './create-emitter'
-import type { IsEqual } from './types'
-import { useDebugValue } from 'react'
-
-/**
- * Todo need to remove this
- */
-export function toType<T>(object?: unknown): T {
-  return object as T
-}
-
-export function useSyncExternalStore<T, S>(
-  emitter: Emitter<T>,
-  selector: (stateValue: T) => S,
-  isEqual?: IsEqual<S>,
-): undefined extends S ? T : S {
-  const value = useSync<T, S>(
-    emitter.subscribe,
-    emitter.getSnapshot,
-    emitter.getSnapshot,
-    selector ? (stateValue) => selector(stateValue) : toType,
-    isEqual,
-  ) as undefined extends S ? T : S
-
-  useDebugValue(value)
-  return value
-}

package/src/create-base-state.ts

@@ -1,35 +0,0 @@
-import type { Emitter } from './create-emitter'
-import { merge } from './merge'
-import { select } from './select'
-import type { BaseState, GetterState } from './types'
-
-interface Options<T> {
-  readonly emitter: Emitter<T>
-  readonly reset: () => void
-  readonly getState: () => T
-  readonly getGetterState: () => GetterState<T>
-}
-export function createBaseState<T>(options: Options<T>): BaseState<T> {
-  const { emitter, getGetterState, reset, getState } = options
-  return {
-    getState,
-    reset,
-    select(selector, isSame) {
-      const state = getGetterState()
-      return select(state, selector, isSame)
-    },
-    merge(state2, selector, isEqualHook) {
-      const state = getGetterState()
-      return merge(state, state2, selector, isEqualHook)
-    },
-    __internal: {
-      emitter,
-    },
-    subscribe(listener) {
-      listener(getState())
-      return emitter.subscribe(() => {
-        listener(getState())
-      })
-    },
-  }
-}

package/src/create-emitter.ts

@@ -1,24 +0,0 @@
-export type EmitterSubscribe<P = undefined> = (listener: (...params: P[]) => void) => () => void
-export interface Emitter<T, R = T, P = undefined> {
-  subscribe: EmitterSubscribe<P>
-  getSnapshot: () => R
-  emit: (...params: P[]) => void
-}
-
-export function createEmitter<T, R = T, P = undefined>(getSnapshot: () => R): Emitter<T, R, P> {
-  const listeners = new Set<(...params: P[]) => void>()
-  return {
-    subscribe: (listener) => {
-      listeners.add(listener)
-      return () => {
-        listeners.delete(listener)
-      }
-    },
-    emit: (...params) => {
-      for (const listener of listeners) {
-        listener(...params)
-      }
-    },
-    getSnapshot,
-  }
-}

package/src/create-getter-state.ts

@@ -1,19 +0,0 @@
-import type { BaseState, GetterState } from './types'
-import { useStateValue } from './use-state-value'
-
-interface Options<T> {
-  readonly baseState: BaseState<T>
-}
-export function createGetterState<T>(options: Options<T>): GetterState<T> {
-  const { baseState } = options
-  const useSliceState: GetterState<T> = (useSelector, isEqualHook) => {
-    return useStateValue(useSliceState, useSelector, isEqualHook)
-  }
-  useSliceState.__internal = baseState.__internal
-  useSliceState.getState = baseState.getState
-  useSliceState.reset = baseState.reset
-  useSliceState.select = baseState.select
-  useSliceState.merge = baseState.merge
-  useSliceState.subscribe = baseState.subscribe
-  return useSliceState
-}

package/src/create.ts

@@ -1,102 +0,0 @@
-import { createEmitter } from './create-emitter'
-import type { SetValue, SetterState, StateDataInternal, DefaultValue, GetterState, IsEqual, UpdateValue } from './types'
-import { getDefaultValue } from './types'
-import { isEqualBase, isObject, isPromise, isSetValueFunction } from './is'
-import { createBaseState } from './create-base-state'
-import { createGetterState } from './create-getter-state'
-
-/**
- * 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 function create<T>(defaultValue: DefaultValue<T>, isEqual: IsEqual<T> = isEqualBase): SetterState<Awaited<T>> {
-  function resolveSetter(value: T, stateSetter: SetValue<T>): T {
-    if (isSetValueFunction(stateSetter)) {
-      return stateSetter(value)
-    }
-    return stateSetter
-  }
-
-  const stateData: StateDataInternal<T> = {
-    updateVersion: 0,
-    value: undefined,
-  }
-
-  function getValue(): T {
-    if (stateData.value === undefined) {
-      stateData.value = getDefaultValue(defaultValue)
-    }
-    return stateData.value
-  }
-  function get(): T {
-    const stateValue = getValue()
-    if (isPromise(stateValue)) {
-      stateValue.then((data) => {
-        stateData.value = data as Awaited<T>
-        emitter.emit()
-      })
-    }
-    return stateValue
-  }
-
-  function set(stateValue: SetValue<T>) {
-    const stateValueData = getValue()
-    const newState = resolveSetter(stateValueData, stateValue)
-    const isEqualResult = isEqual?.(stateValueData, newState)
-    if (isEqualResult || newState === stateValueData) {
-      return
-    }
-    stateData.updateVersion++
-    stateData.value = newState
-    emitter.emit()
-  }
-
-  function update(stateValue: UpdateValue<T>) {
-    if (isObject(stateValue)) {
-      return set((previousState) => {
-        return { ...previousState, ...stateValue }
-      })
-    }
-    set(stateValue as T)
-  }
-
-  const emitter = createEmitter<T>(get)
-
-  const baseState = createBaseState({
-    emitter,
-    getGetterState: () => setterState,
-    getState: get,
-    reset() {
-      const value = getDefaultValue(defaultValue)
-      if (isPromise(value)) {
-        value.then((data) => {
-          set(data as T)
-        })
-        return
-      }
-      set(value)
-    },
-  })
-
-  const getterState: GetterState<T> = createGetterState<T>({ baseState })
-  const setterState: SetterState<T> = getterState as SetterState<T>
-  setterState.setState = set
-  setterState.updateState = update
-  return setterState as SetterState<Awaited<T>>
-}

package/src/index.ts

@@ -1,6 +0,0 @@
-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'

package/src/is.ts

@@ -1,36 +0,0 @@
-import type { Ref, Setter, SetValue } from './types'
-
-export function isPromise(value: unknown): value is Promise<unknown> {
-  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> {
-  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
-}
-
-export function isSet(value: unknown): value is Set<unknown> {
-  return value instanceof Set
-}
-
-export function isArray(value: unknown): value is Array<unknown> {
-  return Array.isArray(value)
-}
-
-export function isEqualBase<T>(valueA: T, valueB: T): boolean {
-  if (valueA === valueB) {
-    return true
-  }
-  return !!Object.is(valueA, valueB)
-}

package/src/merge.ts

@@ -1,41 +0,0 @@
-import { createBaseState } from './create-base-state'
-import { createEmitter } from './create-emitter'
-import { createGetterState } from './create-getter-state'
-import { isEqualBase } from './is'
-import type { IsEqual, GetterState } from './types'
-
-export function merge<T1, T2, S>(
-  state1: GetterState<T1>,
-  state2: GetterState<T2>,
-  selector: (value1: T1, value2: T2) => S,
-  isEqual: IsEqual<S> = isEqualBase,
-): GetterState<S> {
-  let previousData: S | undefined
-  const emitter = createEmitter(() => {
-    const data = selector(state1.getState(), state2.getState())
-    if (previousData !== undefined && isEqual(previousData, data)) {
-      return previousData
-    }
-    previousData = data
-    return data
-  })
-  state1.__internal.emitter.subscribe(() => {
-    emitter.emit()
-  })
-  state2.__internal.emitter.subscribe(() => {
-    emitter.emit()
-  })
-
-  const baseState = createBaseState<S>({
-    emitter,
-    getGetterState: () => getterState,
-    getState: () => selector(state1.getState(), state2.getState()),
-    reset() {
-      state1.reset()
-      state2.reset()
-    },
-  })
-
-  const getterState: GetterState<S> = createGetterState<S>({ baseState })
-  return getterState
-}